Come faccio a creare Unity dalla fonte?

Mi piacerebbe sapere come costruirò Unity dal codice sorgente nell'attuale versione di sviluppo. Si prega di coprire i seguenti argomenti:

• Quali pacchetti sono necessari per compilare Unity?
• Dove dovrei ottenere l'attuale codice sorgente?
• Quali sono i passaggi per configurare e compilare effettivamente Unity?
• È possibile eseguire in modo sicuro l'ultima versione insieme alla versione dei repository?

Costruire l'unità dalla fonte

In questa guida costruirai una versione separata del trunk Unity (installato localmente nella tua home directory), quindi non dovrai preoccuparti di corrompere la versione dai repository Ubuntu e non avrai nemmeno bisogno di ottenere i permessi di root in tutto il intero processo (ad eccezione dell'installazione delle dipendenze di compilazione).

0. Installazione delle dipendenze di compilazione

Dovrai eseguirlo una volta per installare tutte le dipendenze di build necessarie:

sudo apt-get install bzr cmake compiz-dev gnome-common libbamf3-dev libboost-dev \
libboost-serialization-dev libgconf2-dev libgdu-dev libglewmx1.6-dev \
libgnome-desktop-3-dev libibus-1.0-dev libindicator3-dev libjson-glib-dev \
libnotify-dev libnux-2.0-dev libpci-dev libsigc++-2.0-dev libunity-dev \
libunity-misc-dev libutouch-geis-dev libxxf86vm-dev libzeitgeist-dev xsltproc

Se hai repository di codice sorgente (aka deb-src) abilitati, puoi invece usare:

sudo apt-get build-dep unity

1. Preparare l'ambiente

Sostituisci SOURCEe PREFIXcon le directory che vuoi che arrivino alla fonte e costruisci i file. In questo esempio ho inserito entrambi nella mia home directory:

export SOURCE=$HOME/source/unity
export PREFIX=$HOME/build/unity

export PKG_CONFIG_PATH="$PREFIX/lib/pkgconfig:$PKG_CONFIG_PATH"
export LD_LIBRARY_PATH="$PREFIX/lib:$LD_LIBRARY_PATH"
export LD_RUN_PATH="$PREFIX/lib:$LD_RUN_PATH"
export XDG_DATA_DIRS="$PREFIX/share:$XDG_DATA_DIRS"

mkdir -p "$PREFIX"
mkdir -p "$SOURCE"
cd "$SOURCE"

2. Costruire Nux

Probabilmente dovrai prendere l'ultima versione di Nuxper far compilare il trunk Unity:

bzr branch lp:nux
cd nux
./autogen.sh --disable-examples --disable-gputests --disable-tests --prefix="$PREFIX"
make -j4
make install
cd ..

Suggerimento : la maggior parte dei desktop e laptop moderni ha diversi core. Puoi accelerare notevolmente la compilazione sfruttando questo. Il makecomando ha il supporto integrato per questo che puoi attivare usando l' opzione -jN dove N è il numero di lavori da eseguire in parallelo. Una buona regola empirica è eseguire 2 volte il numero di core sul processore. Pertanto, su un normale computer dual core è necessario eseguire make -j4per ridurre al minimo i tempi di compilazione.

3. Costruire l'unità

Ora prendi l'ultimo codice Unity e costruiscilo:

bzr branch lp:unity
cd unity
mkdir build
cd build
cmake .. -DCMAKE_BUILD_TYPE=Debug -DCOMPIZ_PLUGIN_INSTALL_TYPE=local -DGSETTINGS_LOCALINSTALL=ON -DCMAKE_INSTALL_PREFIX="$PREFIX"
make -j4
make install

Ecco fatto, disconnettersi e riconnettersi e si dovrebbe eseguire l'ultimo Unity. In alternativa , puoi eseguire

setsid $PREFIX/bin/unity

4. Aggiornamento

Assicurati di preparare l'ambiente come descritto nel passaggio 1, quindi inserisci semplicemente entrambe le directory di livello superiore nuxed unityesegui bzr pull, ricostruisci e reinstalla.

Suggerisco di rimuovere e ricreare la builddirectory nella unitydirectory, per assicurarsi che nessun vecchio file stia rovinando la tua build.

5. Rimozione di Unity

Rimuovere le tre directory $SOURCE, $PREFIXe ~/.compiz-1.

Link utile:

• http://unity.ubuntu.com/getinvolved/development/unity/

Ho creato uno script basato sullo script di compilazione di Wayland e su queste istruzioni per automatizzare l'installazione dei prerequisiti, la clonazione, l'aggiornamento, la configurazione e la creazione di Unity.

https://github.com/bitshifter/Unity-Build/raw/master/build-unity.sh

Costruire nella tua home directory

A volte per motivi di test è utile creare Unity e nux nella directory home in modo da poter provare a vedere se qualcosa è stato risolto nel trunk senza andare in giro con pacchetti e / o PPA. Ho chiesto a Jason Smith (Unity Dev) come ha costruito Unity e mi ha spiegato il suo metodo:

1. Assicurati di avere tutte le dipendenze di build da questa risposta.

2. Per prima cosa crea una directory nella tua casa chiamata "staging", qui costruiremo Unity. Crea un piccolo script che preparerà l'ambiente di compilazione, sostituisci la home directory con la tua:

   #!/bin/bash
   
   PREFIX=/home/jorge/staging
   
   export XDG_DATA_DIRS="$PREFIX/share:$XDG_DATA_DIRS"
   export LD_LIBRARY_PATH="$PREFIX/lib/"
   export PKG_CONFIG_PATH="$PREFIX/lib/pkgconfig/"
   

   Lo chiamo unity.she lo eseguo ogni volta che voglio costruire Unity. Quindi in pratica chmod +x unity.she poi ./unity.shquando vuoi costruire.

3. Build nux:

   bzr branch lp:nux
   cd nux
   ./autogen.sh --prefix=/home/jorge/staging
   make -j4
   make install
   cd ..
   

4. Build Unity:

   bzr branch lp:unity
   cd unity
   mkdir build
   cd build
   cmake .. -DCMAKE_INSTALL_PREFIX=/home/jorge/staging/ -DCMAKE_BUILD_TYPE=Debug -DCOMPIZ_PLUGIN_INSTALL_TYPE=local -DGSETTINGS_LOCALINSTALL=ON
   make -j4
   make install
   

NOTA: Questo crea nux e unità nella tua home directory, non c'è bisogno di sudo qui o qualcosa del genere.

• Disconnettersi e riconnettersi eseguirà automaticamente questa versione di Unity / nux da quando è stata integrata ~/.compiz
• Per ripristinare i normali pacchetti basta disconnettersi, eliminare ~/.compize accedere nuovamente.

Il codice sorgente per l'ambiente predefinito (Unity) è disponibile nel pacchetto unity. Installa la fonte con apt-get source unity, le dipendenze per costruirla sudo apt-get build-dep unitye scacciarla.

Questo ti permetterà di posizionare il launcher a destra, in basso, in alto, ecc.

C'è un'eccellente documentazione ufficiale qui - Sviluppo di unità .

Ecco un estratto da esso sulla creazione di Unity: installazione dal sorgente e compilazione

Costruire l'unità

Queste istruzioni ti aiuteranno a costruire unità dalla fonte. Tuttavia, ci sono alcune cose da considerare:

• Si consiglia di non copiare mai nulla di ciò che è stato creato localmente al di fuori della propria directory home. Farlo significa chiedere problemi, specialmente mentre stiamo costruendo l'intera shell del desktop. Se riesci a rovinare la shell del desktop a livello di sistema sarai un programmatore molto triste!
• Si presume che tu stia eseguendo la versione precisa di Ubuntu.
• Si presume anche che tu voglia costruire unità dal tronco (cioè, lp: unità).

Ottenere il codice sorgente:

Se non hai già installato Bazaar, installalo ora:

sudo apt-get install bzr

Ti consigliamo di creare una cartella per il codice di unità. Fai qualcosa del genere:

mkdir -p ~/code/unity
cd ~/code/unity

Prendiamo il codice dal launchpad:

bzr branch lp:unity trunk

Questo potrebbe richiedere del tempo.
Installazione delle dipendenze di build:

Dobbiamo ottenere le dipendenze costruite per l'unità. Per fortuna, apt-get rende questo banale:

sudo apt-get build-dep unity

Unità di compilazione:

Utilizzare questo set di funzioni bash per semplificare notevolmente questo passaggio. Per usarli, copia il seguente codice bash in un file nella tua home directory chiamato .bash_functions:

function recreate-build-dir()
{
   rm -r build
   mkdir build
   cd build
}

function remake-autogen-project()
{
    ./autogen.sh --prefix=$HOME/staging --enable-debug
    make clean && make && make install
}

function remake-unity()
{
    recreate-build-dir
    cmake .. -DCMAKE_BUILD_TYPE=Debug -DCOMPIZ_PLUGIN_INSTALL_TYPE=local -DCMAKE_INSTALL_PREFIX=$HOME/staging/ -DGSETTINGS_LOCALINSTALL=ON
    make  && make install
}

function unity-env
{
 export PATH=~/staging/bin:$PATH
 export XDG_DATA_DIRS=~/.config/compiz-1/gsettings/schemas:~/staging/share:/usr/share:/usr/local/share
 export LD_LIBRARY_PATH=~/staging/lib:${LD_LIBRARY_PATH}
 export LD_RUN_PATH=~/staging/lib:${LD_RUN_PATH}
 export PKG_CONFIG_PATH=~/staging/lib/pkgconfig:${PKG_CONFIG_PATH}
 export PYTHONPATH=~/staging/lib/python2.7/site-packages:$PYTHONPATH
}

Ora eseguilo in un terminale:

echo ". ~/.bash_functions" >> ~/.bashrc

Ciò garantisce che la prossima volta che si apre una shell bash, le funzioni sopra elencate saranno disponibili. Per evitare di dover chiudere e riaprire un terminale, possiamo leggerli manualmente solo una volta:

. ~/.bash_functions

Ora dovresti essere in grado di eseguire:

remake-unity

dalla trunk/directory che abbiamo creato in precedenza. Ecco fatto: stai costruendo l'unità!

L'installazione è diventata più complicata di recente: un nuovo modulo è stato aggiunto a compiz chiamato GTK Load (o si arresterà in modo anomalo in XInternAtom). Dobbiamo attivare questo modulo per usare 4.0.1, ma attivandolo si bloccherà l'unità 3.8.

Sta diventando difficile tenerli entrambi. Il modo in cui l'ho fatto è stato di:

• vai nella cartella compiz-1 e rinomina tutto .so con .so1, tranne libgtkloader.so
• riavvia compiz con unità 4.0.1
• attiva il modulo di caricamento gtk in compizconfig-settings-manager
• rinominare le librerie in .so
• riavvia compiz.