Enkel versionskontroll med Git i Android Studio

Som du vet är det bästa tillvägagångssättet att alltid använda källhanteringshantering (SCM) för dina projekt – även personliga projekt. Visste du att Android Studio har en fantastisk integration med Git för källkontrollhantering? Om du inte visste det eller inte har erfarenhet av att använda den, fortsätt att läsa det här inlägget. Även om du redan har använt Android Studios Git-integration kan du kanske ändå hämta några användbara knep i det här inlägget.

Jag kommer att visa dig de många funktionerna i Git-stödet i Android Studio och även hur enkelt det är att göra de olika Git-operationerna (commit, push, pull, branch osv.) inifrån Android Studio.

I den här handledningen går jag igenom listan över SCM-funktioner som finns tillgängliga i Android Studio. Vi kommer att titta på följande områden:

• integrera ett nytt Android Studio-projekt med Git
• arbeta med GitHub eller Bitbucket
• utforska fönstret Versionskontroll
• .
• commits
• branches
• pushing and pulling from a remote repository

Förutsättningar

För att kunna följa den här handledningen, behöver du:

• En grundläggande förståelse för det distribuerade versionskontrollsystemet Git
• Android Studio 3.0 eller högre

1. Skapa ett Android Studio-projekt

Sätt igång Android Studio och skapa ett nytt projekt (du kan döpa det till GitApplicationDemo) med en tom aktivitet som heter MainActivity.

2. Integrera Git

När ditt Android Studio-projekt har skapats klickar du på VCS-menyn, håller muspekaren på menyn Importera till versionskontroll och väljer Skapa Git-repositorium…

Välj sedan den översta överordnade mappen för ditt Android Studio-projekt.

Klicka på OK-knappen för att initialisera projektet med Git. Under huven utför Android Studio Git-kommandot:

git init

Som en påminnelse kan du se vad det här kommandot gör:

Detta kommando skapar ett tomt Git-förråd – i princip en .git-katalog med underkataloger för objects, refs/heads, refs/tags och mallfiler. En inledande HEAD fil som refererar till HEAD för mastergrenen skapas också.

En informationsdialog öppnas:

Detta berättar om en fil som heter vcs.xml i mappen .idea. Den här mappen innehåller bara projektspecifika inställningar. Observera att detta är det format som används av alla nyare versioner av IntelliJ IDEA.

Det är egentligen så att filerna i .idea/ inte ska nå Git – så du ska lägga till den i .gitignore.

Som standard är vi bytta till mastergrenen. Du kan alltid se projektets aktuella gren i det nedre högra hörnet av Android Studio.

3. Integrering med GitHub eller Bitbucket

Du kan enkelt arbeta med alla dina Android-källkodsarkiv som finns i ett GitHub- eller Bitbucket-konto i Android Studio. Låt mig visa dig hur du gör det.

Navigera till File > New > Project från Version Control > GitHub.

(Om du vill arbeta på en repo från Bitbucket väljer du Bitbucket istället. Om du bara vill klona en Git-repo från internet till din lokala maskin väljer du menyalternativet Git.)

Nästan anger du dina GitHub-kontouppgifter och klickar på Logga in.

Om inloggningen lyckades öppnas dialogrutan Clone Repository. Den här dialogrutan visar en rullgardinsmeny som innehåller en lista över de repositories på GitHub som du för närvarande äger eller har arbetat med.

Klicka på Clone (klona) för att klona repo:n till din lokala dator i den redan valda överordnade katalogen.

4. Fönstret för versionskontroll

När vi lyckats initiera vårt Android Studio-projekt med Git kommer Android Studio att visa fönstret för versionskontroll. Klicka på fliken Versionskontroll (längst ner till vänster i Android Studio) och låt oss utforska vad vi har där. Observera att du kan använda Alt-9 för att snabbt öppna det här fönstret.

I det här fönstret har vi tre olika flikar: Lokala ändringar, Konsol och Logg.

Fliken Lokala ändringar

Detta visar en lista över filer som har ändrats lokalt (på din egen maskin) och som ännu inte har överförts till arkivet.

Vi tar en titt på de objektverktygsfält som är tillgängliga när du är på fliken Lokala ändringar.

1. Klicka på den här ikonen för att uppdatera statusen för dina filer på den aktuella arbetsplatsen. Genvägen är Control-F5.
2. När du klickar på den här ikonen bekräftar du dina aktuella ändringar. Genvägen är Control-Alt-Z.
3. Klicka på den här ikonen för att återkalla valda ändringar.
4. Klicka på den här ikonen för att skapa en ny ändringslista. Observera att en ändringslista är en uppsättning ändringar i filer som representerar en logisk ändring i källkoden. Genvägen är Alt-Insert.
5. Klicka på den här knappen för att ta bort den valda ändringslistan.
6. För att göra en ändringslista aktiv klickar du bara på den här ikonen.
7. Om du vill flytta en markerad fil till en annan ändringslista klickar du på den här ikonen.

1. Klicka på den här ikonen för att expandera och visa alla filer.
2. Klicka på den här ikonen för att fälla ihop alla filer.
3. Klicka på den här ikonen för att visa de ändrade filerna som är grupperade efter mappar.
4. Klicka på den här ikonen för att kopiera sökvägen till den valda filen till systemets urklipp.
5. Klicka på den här ikonen för att visa noden ignorerade filer med listan över befintliga filer som ignoreras av Git.
6. Klicka på den här ikonen för att ställa in listan över filer som kommer att ignoreras av Git.
7. Klicka på den här ikonen för att öppna fönstret Preview Diff och jämföra den aktuella filen med den senaste överförda revideringen.

Fliken Konsol

I den här fliken ser vi resultatet av att utföra Git-relaterade kommandon. Observera att du inte kan skriva Git-kommandon i den här fliken – gör det istället i terminalfönstret i Android Studio.

Fliken Logg

Den här fliken visar alla ändringar som har lagts in i alla grenar i det lokala och fjärrförvaret. I den här fliken kan du bläddra bland de överföringar som gjorts till vilken gren som helst.

Sökrutan används för att söka efter commits som har den inmatade strängen eller ett reguljärt uttryck.

1. Den här rullgardinsmenyn som används för att filtrera commits efter gren. Om du vill visa alla lokala och fjärrkommiteringar väljer du bara All (standard).
2. För att filtrera commits efter författare använder du den här rullgardinslistan. Du måste skriva författarens namn för att visa deras commits. Välj Alla för att visa alla användares ändringar.
3. Använd den här rullgardinslistan för att filtrera commits efter ett tidsintervall eller för ett visst datum. Om du vill specificera datumet klickar du helt enkelt på Välj och väljer datum. Välj Alla för att visa ändringar som gjorts på alla datum.
4. Använd den här rullgardinsmenyn för att filtrera commits efter sökvägen för ändrade filer.
5. Den här knappen (IntelliSort) gör det möjligt att se sammanslagningar på ett bekvämare sätt, genom att först visa inkommande commits, direkt under sammanslagningscommit.
6. Om den här knappen är aktiverad visas långa grenar i sin helhet, även om det inte finns några commits i dem.
7. Använd den här knappen för att uppdatera listan över commits i projektet.
8. För att gå till en hash, tagg eller gren använder du helt enkelt den här knappen.
9. Klicka på den här knappen för att tillämpa ändringar från det valda commit till den aktuella grenen.
10. Klicka på den här knappen för att markera de commits från den valda grenen som ännu inte har tillämpats på den aktuella grenen.

Du kan läsa mer om verktygsfönstret Versionskontroll i dokumentationen till IntelliJ IDEA.

5. Gör en överföring

Du märker att när vi konfigurerade Git-integrationen med vårt Android Studio-projekt blev färgen på vårt filnamn brun. Enligt den officiella IntelliJ IDEA-dokumentationen gäller följande för filer med bruna etiketter:

Filen finns lokalt, men finns inte i arkivet och är inte planerad att läggas till.

Vi ska nu se hur man gör en commit i Android Studio. Men först måste vi lägga till våra ändringar i arbetskatalogen till staging-området. I konsolen skulle vi använda kommandot git add.

git add <file> || <directory>

Men vi kan göra detta direkt från Android Studio. Välj rullgardinsmenyn Unversioned Files på fliken Local Changes, högerklicka och gå till Git > Add eller använd Control-Alt-A. Kom ihåg att om du väljer rotmappen läggs allt som finns i den till stagingområdet.

Nu kommer du att observera att färgerna på dina filmärken har ändrats från brunt till grönt. Här är vad IntelliJ IDEA-dokumentationen säger om filnamn som är färgade i grönt:

Filen är planerad att läggas till i arkivet.

Om du vill veta mer om de olika färger som ett filnamn kan ha beroende på filstatusen i Android Studio (IntelliJ IDEA) kan du läsa dokumentationen om filstatusens höjdpunkter.

För att slutligen bekräfta våra ändringar klickar du på knappen Commit changes (bekräfta ändringar) på fliken Local Changes (lokala ändringar) och dialogrutan Commit Changes (bekräfta ändringar) öppnas.

1. Här kan vi markera eller avmarkera filer som ska inkluderas i denna commit. Som standard är alla staged-filer markerade.
2. Skriv ditt meddelande om överföring här inne. Om du har ett tidigare skrivet meddelande kommer det att visas här som standard.
3. Välj operation(er) som ska utföras innan du överför till Git.
4. Sidekomparation av de ändrade filerna sida vid sida.
5. Med den här rullgardins-knappen kan du antingen göra en överföring och pushning eller bara en överföring.

För att göra en commit skriver vi ett commitmeddelande:

Initial commit 

Välj Commit i rullgardinsmenyn Commit för att slutligen bekräfta dina ändringar. Observera att du kan använda genvägen Control-K för att bekräfta ändringar när som helst från Android Studio.

Om du nu återbesöker fliken Lokala ändringar i fönstret Versionskontroll kommer du inte längre att se några av dina filer listade där – eftersom vi framgångsrikt har överfört dem till vår lokala repo.

Notera att du också kan navigera till VCS > Git > Commit File… för att göra en commit och VCS > Git > Add för att lägga till en fil för staging. Dessutom kan du klicka på ikonen commit changes i den övre huvudverktygsfältet i Android Studio för att snabbt göra en commit (eller commit and push).

I vår klass MainActivity.kt gjorde jag en enkel ändring i klassen genom att åsidosätta onResume(). Du kommer att märka att färgen på filnamnet efter ändringen nu är blå; det betyder att vi har ändrat filen.

Visa Commit Log

Nu kan du återvända till fönstret Versionskontroll igen och gå till fliken Logg. Vad du nu kommer att se är de commits som har gjorts till det här projektet. Om du vill få mer information om en viss överföring klickar du bara på den.

1. Denna huvudruta visar alla commits på projektet enligt det valda filtret. Med andra ord visar den oss commit-historiken.
2. Denna ruta visar de filer och mappar som påverkas av den commit som valts i rutan för commits historik.
3. Den här rutan visar mer information om den valda överföringen.

Om du högerklickar på en commit kan du också se en meny där du kan kopiera revisionsnumret, skapa en patch, checka ut en revision, grena från den commit, skapa en ny tagg och återställa den aktuella grenen till den commit.

Nu ska vi titta på hur vi kan se vilken kod som lagts till, redigerats eller tagits bort. Med andra ord vill vi kontrollera – i mer detalj – vilka ändringar som gjorts.

Klicka helt enkelt på ikonen show diff ovanför fönstret där de filer som påverkats av commit visas. En genväg är att använda Control-D eller att dubbelklicka på filen eller mappen.

Det du ser är en dialogruta Show Diff som visar skillnaderna mellan föregående commit och vald commit.

En grönfärgad region i filen markerar rader som lagts till i filen – du borde se några om du följer med. Grå regioner markerar linjer som tagits bort. Och blå markerar linjer som ändrades. Försök att utforska de filter och ikonknappar som finns tillgängliga högst upp i dialogrutan Visa Diff för att lära dig mer om den.

Notera att du även kan se ändringar i bilder i dialogrutan Visa Diff!

Om du högerklickar på en fil har du även möjlighet att se skillnaden mellan den senaste och den aktuella överföringen av filen – visa diff (genväg Control-D). Du kan också redigera källan (F4), öppna versionen i arkivet, återkalla valda ändringar, visa historik för revideringen och visa detaljer om bekräftelsen för den filen.

6. Skapa en Git-gren

Mastergrenen kommer som standard att vara aktuell. Det rekommenderas dock att alltid grena ut från master och göra ditt arbete på en separat, funktionsspecifik gren. När du är klar med kodningen av din funktion (och när du har testat dina ändringar) slår du sedan ihop dina ändringar till mastergrenen.

Låt oss se hur man skapar en gren från master.

Gå till det nedre högra hörnet i Android Studio och klicka på rullgardinsmenyn Git: master.

Klicka på knappen Ny gren.

Inför namnet på grenen. I vårt fall använder du dev.

Slutligen klickar du på OK-knappen för att Android Studio automatiskt ska skapa dev-grenen och även checka ut till den grenen.

Vi befinner oss nu för närvarande i dev-grenen. Som du kan se nedan:

Under huven utför Android Studio kommandot:

 git checkout -b dev

Notera att vi också kan skapa en ny gren genom att navigera till VCS > Git > Branches > New Branch.

7. Sammanslagning av Git-branscher

Inom dev-branschen skapar vi bara en grundläggande aktivitet ProfileActivity.kt och dess layoutfiler och överför dina ändringar. Vi kommer att se hur du kan sammanföra dev till master direkt i Android Studio.

Gå och checka ut från den aktuella grenen (dev) till master-grenen (vilket innebär att vi byter från dev till master).

Sammanslagning, utcheckning, radering, jämförelse, byta namn på gren

Om du klickar på en gren visas några åtgärder som du kan utföra på den grenen. Operationerna inkluderar sammanslagning, jämförelse av två grenar, byta namn på grenen, ombasering, utcheckning och radering av grenen.

Vi kommer att titta på hur man slår ihop en gren i det här inlägget. I mastergrenen slår du ihop dev-grenen genom att navigera till dev-grenen och klicka på Merge i menyn.

Så är det! Vi har nu framgångsrikt sammanfogat vår dev-gren till mastergrenen.

Här bakom kulisserna utför Android Studio kommandot:

git merge dev

Bemärk att vi även kan göra avancerad sammanslagning direkt i Android Studio. Vi kan ange sammanslagningsstrategi (Resolve, Recursive, Octopus, Ours eller Subtree) eller att inte använda det snabba sammanslagningsläget.

För att ställa in detta vid sammanslagning navigerar du till VCS > Git > Merge Changes…

Här kan du välja flera grenar som ska slås samman, välja sammanslagningsstrategi och skriva ett commitmeddelande. Det rekommenderas starkt att du verkligen förstår dessa sammanslagningsstrategier och om du ska använda läget för snabbspolning före sammanslagningen.

8. Pushing till ett fjärrarkiv

Varje Git-projekt bör ha ett fjärrarkiv eller ett centralt arkiv där andra utvecklare kan samarbeta med projektet från var som helst i världen. I Android Studio är det också möjligt att pusha våra commits eller ändringar till ett fjärrarkiv. För att göra det navigerar du till VCS > Git > Push…

Här kan vi lägga till fjärrförvarets URL genom att klicka på länken Define remote i dialogrutan Push Commits som öppnas. Slutligen klickar du på Push-knappen när du är klar! En genväg är att använda Control-Shift-K.

Android Studio utför följande kommando bakom kulisserna:

git push

Du kan också snabbt göra en commit med en push genom att klicka på ikonen commit changes i huvudverktygsfältet eller använda Control-K.

9. Pulling från ett fjärrarkiv

För att uppdatera ditt projekt (för att göra en pull) med de senaste ändringarna från fjärrarkivet (du bör redan ha lagt till fjärrursprunget), navigerar du till VCS > Git > Pull. Detta kommer automatiskt att uppdatera ditt Android Studio-projekt med den senaste koden från fjärrförrådet.

För att initiera en pull kan du också klicka på ikonen för uppdatering av projekt i huvudverktygsfältet eller använda genvägen Control-T.

Om du gör detta kommer Android Studio att utföra Git pull-kommandot bakom kulisserna:

git pull 

Observera att om du stöter på en sammanfogningskonflikt när du drar eller skjuter kommer Android Studio att visa en riktigt praktisk dialogruta för sammanfogningskonflikter som hjälper dig att lösa konflikten.

Slutsats

I den här handledningen har du lärt dig hur enkelt det är att utföra olika Git-operationer som du vanligtvis gör på kommandoraden eller i terminalen. Genom att använda Android Studios Git-verktyg blir det enklare och effektivare att samarbeta med andra utvecklare om Android-projekt.

Om du vill lära dig mer om kodning för Android kan du kolla in några av våra andra kurser och handledningar här på Envato Tuts+!

• 
  Android
  Visa Material Design-dialoger i en Android-app
  Chike Mgbemena
• 
  Android
  Skapa en materialdesignad app. Tabbed Interface i en Android-app
  Chike Mgbemena
• 
  Android
  Bygg en musikapp med en Android-appmall
  Chike Mgbemena