மாற்றங்களைச் செய்வது மற்றும் உள்நாட்டில் சோதனை¶
இந்த பக்கத்தில் உங்கள் கருவியிற்கான உபுண்டு டச் சிச்டம் மென்பொருளை எவ்வாறு உருவாக்குவது என்பது பற்றிய தகவல்களைக் காண்பீர்கள். உங்கள் உபுண்டு டச் கருவியில் முன்பே நிறுவப்பட்ட பெரும்பாலான மென்பொருள்கள் சாதனப் படத்தில் டெபியன் தொகுப்பின் வடிவத்தில் அனுப்பப்படுகின்றன. இந்த வடிவத்தை டெபியன், உபுண்டு மற்றும் லினக்ச் புதினா போன்ற பல லினக்ச் விநியோகங்களால் பயன்படுத்தப்படுகிறது. டெப் தொகுப்புகளில் ஏராளமான ஆவணங்கள் <https://www.debian.org/doc/manuals/maint-guide/index.en.html>`__ கிடைக்கின்றன, எனவே நாங்கள் அதை இங்கே மறைக்க மாட்டோம். தவிர, பெரும்பாலான சந்தர்ப்பங்களில், புதிதாக புதிய தொகுப்புகளை உருவாக்குவதை விட, இருக்கும் மென்பொருளை மாற்றியமைக்க வேண்டியிருக்கும். இந்த காரணத்திற்காக, இந்த வழிகாட்டி பெரும்பாலும் ஏற்கனவே இருக்கும் உபுண்டு தொடு தொகுப்பை மீண்டும் தொகுப்பது பற்றியது.
உபுண்டு டச் சிச்டம் மென்பொருளை உள்நாட்டில் உருவாக்க மூன்று வழிகள் உள்ளன:
Sbuild ஐப் பயன்படுத்தி ஒரு க்ரூட்டில் தொகுப்புகளை உருவாக்குதல்
Sbuild மற்றும் CrossBuilder இன் நன்மை தீமைகள்¶
Sbuild மிகக் குறைந்த Chroot-அடிப்படையிலான உருவாக்க சூழலைப் பயன்படுத்துகிறது, அதே நேரத்தில் கிராச்வில்டர் எல்எக்ச்டி கொள்கலனைப் பயன்படுத்துகிறது. குறுக்கு கட்டமைப்பாளருடன் முன்பே நிறுவப்பட்ட கட்டட சார்புகளை உருவாக்கும்போது தவறவிடக்கூடும், அவை SBUILD ஆல் பிடிக்கப்படுகின்றன. எல்எக்ச்டி கொள்கலன் தொடர்ந்ததால் கிராசிபில்டர் அடுத்தடுத்த கட்டடங்களுக்கு விரைவாக இருக்க முடியும். ஒவ்வொரு ஓட்டத்திலும் அனைத்து உருவாக்க சார்புகளையும் Sbuild நிறுவுகிறது. ஏதேனும் சிக்கல்களைக் கண்டறிவதற்காக கட்டப்பட்ட தொகுப்புகளில் கட்டப்பட்ட தொகுப்புகளில் lintian கிராச் பில்டரால் எல்.எக்ச்.டி.யின் பயன்பாடு எளிதாக ஆய்வு, பிழைத்திருத்தம் மற்றும் உருவாக்க சூழலை கையேடு மாற்றியமைக்க அனுமதிக்கிறது. கிராச் பில்டர் தானாகவே ADB வழியாக இணைக்கப்பட்ட கருவியில் பில்ட் தொகுப்புகளை வரிசைப்படுத்தலாம்.
முகவரி-புத்தகம்-APP (தொடர்புகள் பயன்பாடு) ஒரு எடுத்துக்காட்டு பயன்படுத்தும் குறுக்குவழியின் பயன்பாட்டை நாங்கள் ஆராய்வோம்.
டெவெல் சேனலில் இருந்து நிறுவப்பட்ட உபுண்டு டச் கொண்ட கருவியைப் பயன்படுத்தி தொகுப்புகளை உருவாக்க மட்டுமே பரிந்துரைக்கிறோம். உபுண்டு தொடு குறியீட்டின் மிக தற்போதைய நிலைக்கு எதிராக உங்கள் மாற்றங்களை நீங்கள் சோதித்துப் பார்க்கிறீர்கள் என்பதை இது உறுதி செய்கிறது.
ஒரு கட்டமைப்பிற்கு ஒரு தொகுப்பைத் தயாரித்தல்¶
sbuild or crossbuilder need to be invoked from a debianized package source tree (i.e. the package sources with a debian subdirectory), UBports packages mostly consists of git repositories containing native or non-native packages. Native packages can be built directly and the following script can be used in order to prepare a non-native package for a build:
#!/bin/sh
PATH=/bin:/usr/bin
die() {
if [ $# -gt 0 ]; then
printf "%s\n" "$1" >&2
fi
exit 1
}
if [ ! -d "./debian" ]; then
die "not in a debianized package directory"
fi
if [ -f "./debian/ubports.source_location" ]; then
{
read -r src_url && \
read -r src_filename
} < "./debian/ubports.source_location" || \
die "failed to parse ubports.source_location"
case ${src_url} in
http://*|https://*|ftp://*)
;;
*)
die "invalid url: \"${src_url}\""
;;
esac
src_filename="$(basename "${src_filename}")"
wget -O "../${src_filename}" "${src_url}" || \
die "failed to download source archive"
fi
Sbuild ஐப் பயன்படுத்தி ஒரு க்ரூட்டில் தொகுப்புகளை உருவாக்குதல்¶
sbuild என்பது ச்ரூட். இது முன்பே நிறுவப்பட்ட தொகுப்புகளின் குறைந்தபட்ச தொகுப்பைக் கொண்ட தனிமைப்படுத்தப்பட்ட உருவாக்க சூழலைப் பயன்படுத்துவதன் மூலம் யுபிதுறைமுகங்கள் தொஒ அமைப்பில் தொகுப்பு உருவாக்க செயல்முறையை நெருக்கமாக ஒத்திருக்கிறது. இது காணாமல் போன எந்தவொரு கட்டட சார்புகளையும் கண்டறிகிறது மற்றும் லிண்டியன்.
Sbuild ஐப் பயன்படுத்தி மூன்று வகையான கட்டிடங்கள் உள்ளன:
நேட்டிவ் பில்ட் - புரவலன் கட்டிடக்கலை இலக்கு கட்டமைப்போடு பொருந்தும்போது இந்த வகை கட்டிடம் பயன்படுத்தப்படுகிறது.
கிராச் கம்பைல் பில்ட் - புரவலன் கட்டமைப்பு இலக்கு கட்டமைப்புடன் பொருந்தாதபோது இந்த வகை கட்டிடம் பயன்படுத்தப்படுகிறது. நிறுவ முடியாத வெளிநாட்டு கட்டமைப்பு சார்புகள் காரணமாக இந்த முறை தோல்வியடையக்கூடும். அவ்வாறான நிலையில் நீங்கள் மற்றொரு முறையைப் பயன்படுத்த வேண்டும்.
QEMU கிராச் ஆர்கிடெக்சர் பில்ட் - இந்த முறை ஒரு புரவலன் கட்டமைப்பில் ஒரு போலி சொந்த கட்டமைப்பைச் செய்ய உங்களை அனுமதிக்கிறது, இது இலக்கு கட்டமைப்புடன் பொருந்தாது, வெளிநாட்டு கட்டமைப்பு சார்பு சிக்கல்களைத் தவிர்க்கிறது. இந்த முறையின் குறைபாடு மெதுவான விரைவு, இது கட்டிடக்கலை பைனரி மொழிபெயர்ப்புகளின் மேல்நிலைகளால் ஏற்படுகிறது. Qemu.
முன்நிபந்தனைகள்¶
டெபியன் 11 (புல்செய்) அல்லது அதற்குப் பிறகு அல்லது உபுண்டு 20.04 (குவிய ஃபோசா) அல்லது அதற்குப் பிறகு இயங்கும் புரவலன் அமைப்புத் தேவை. பிற விநியோகங்களில் டெபியன் அல்லது உபுண்டுவை அமைப்பதற்கான எளிதான மற்றும் செயல்திறன் வழி, எல்எக்ச்.டி.
A LXD container requires the following configuration setting in order to allow debootstrap to use the mknod system call for creating pseudo devices such as /dev/null inside a chroot:
lxc config set <container> security.syscalls.intercept.mknod true
தொகுப்புகளை உருவாக்கும் பயனர் சூடோ ஐப் பயன்படுத்தி சூப்பர் யூசர் சலுகையுடன் கட்டளைகளை இயக்க அனுமதிக்கப்படுவார் என்று கருதப்படுகிறது.
sbuild uses schroot in order to manage chroots which in turn uses debootstrap for creating the chroot. The required packages are installed with:
sudo apt install sbuild schroot devscripts debhelper dh-migrations ccache
ஒரு டெபியன் அல்லது உபுண்டு அமைப்பும் ஒரு மெய்நிகர் இயந்திரத்திற்குள் நிறுவப்படலாம், இருப்பினும் இது செயல்திறன் மேல்நிலையுடன் வருகிறது.
Sbuild ஐ அமைத்தல்¶
An unprivileged user needs to be added to the sbuild group in order to gain the necessary privilege to build packages:
sudo sbuild-adduser <username>
The build user can configure sbuild by creating a file ~/.sbuildrc as follows:
cat >~/.sbuildrc <<'EOF'
# directory containing the build logs
$log_dir = "$HOME/logs";
1;
EOF
மேலும் தனிப்பயனாக்கங்களுக்கு எடுத்துக்காட்டு கோப்பை /usr/share/doc/sbuild/examples/example.sbuildrc.
Create the directory ~/logs if it does not exist, yet:
mkdir ~/logs
UBPORTS தொகுப்புகள்¶
சில உபுண்டு டச் தொகுதிகளை உருவாக்குவதற்கு யுபிதுறைமுகங்கள் தொகுப்பு களஞ்சியத்திலிருந்து புரவலன் கணினியில் நிறுவப்பட வேண்டிய தொகுப்புகள் தேவைப்படுகின்றன.
In that case UBports package repository needs to be added on the host machine. First initialize the chroot_repo and chroot_distro variables as show in the Native build section and then add the repository by using:
wget 'http://repo.ubports.com/keyring.gpg' -O - | sudo tee "/usr/share/keyrings/ubports-keyring.gpg" >/dev/null
printf 'deb [signed-by=/usr/share/keyrings/ubports-keyring.gpg] %s %s main\n' "${chroot_repo}" "${chroot_distro}" | sudo tee "/etc/apt/sources.list.d/ubports.list" >/dev/null
Install the needed packages using:
sudo apt update
sudo apt install click-dev gobject-introspection
பூர்வீக உருவாக்கம்¶
In order to create a chroot based on Ubuntu 20.04 (Focal Fossa) with the amd64 architecture under the directory /srv/chroot/ubports-${chroot_distro}-amd64 (chroot_base can be changed if needed) the following variables can be defined for later use by the actual commands:
chroot_distro=focal
chroot_base=/srv/chroot/ubports-${chroot_distro}-amd64
chroot_repo=http://repo2.ubports.com/
For creating a chroot based on Ubuntu 16.04 (Xenial Xerus) with the amd64 architecture define the following variables instead:
chroot_distro=xenial
chroot_base=/srv/chroot/ubports-${chroot_distro}-amd64
chroot_repo=http://repo.ubports.com/
In both cases the chroot will be created by running the following command:
sudo sbuild-createchroot --components=main,restricted,universe --extra-repository="deb http://archive.ubuntu.com/ubuntu/ ${chroot_distro}-updates main restricted universe" --include=ccache "${chroot_distro}" "${chroot_base}" http://archive.ubuntu.com/ubuntu/
The UBports package repository needs to be added using:
wget 'http://repo.ubports.com/keyring.gpg' -O - | sudo tee "${chroot_base}/usr/share/keyrings/ubports-keyring.gpg" >/dev/null
printf 'deb [signed-by=/usr/share/keyrings/ubports-keyring.gpg] %s %s main\n' "${chroot_repo}" "${chroot_distro}" | sudo tee "${chroot_base}/etc/apt/sources.list.d/ubports.list" >/dev/null
Synchronizing package index files and subsequent package upgrades can be performed using:
sudo sbuild-update -u -d ${chroot_distro}
A build can be started from inside the debianized package source directory using:
sbuild -d ${chroot_distro}
குறுக்கு தொகுப்பு உருவாக்க¶
The only difference with the native build comes in the command for starting the build which is the following:
sbuild --host=arm64 --build=amd64 -d "${chroot_distro}"
QEMU குறுக்கு கட்டிடக்கலை உருவாக்க¶
To simplify the chroot setup, we use mk-sbuild from the ubuntu-dev-tools package. The qemu-user-static package allows execution of non-native target executables just like native ones.
Install the packages with the following commands:
sudo apt install ubuntu-dev-tools qemu-user-static
In order to create a chroot based on Ubuntu 20.04 (Focal Fossa) with the arm64 architecture under the directory /var/lib/schroot/chroots/ubports-${chroot_distro}-arm64 (chroot_base can be changed if needed) the following variables can be defined for later use by the actual commands:
chroot_arch=arm64
chroot_distro=focal
chroot_base=/var/lib/schroot/chroots/ubports-${chroot_distro}-${chroot_arch}
chroot_repo=http://repo2.ubports.com/
For creating a chroot based on Ubuntu 16.04 (Xenial Xerus) with the arm64 architecture define the following variables instead:
chroot_arch=arm64
chroot_distro=focal
chroot_base=/var/lib/schroot/chroots/ubports-${chroot_distro}-${chroot_arch}
chroot_repo=http://repo.ubports.com/
In both cases the chroot will be created by running the following command:
mk-sbuild --arch=${chroot_arch} ${chroot_distro} --name ubports-${chroot_distro}
The UBports package repository needs to be added using:
wget 'http://repo.ubports.com/keyring.gpg' -O - | sudo tee "${chroot_base}/usr/share/keyrings/ubports-keyring.gpg" >/dev/null
printf 'deb [signed-by=/usr/share/keyrings/ubports-keyring.gpg] %s %s main\n' "${chroot_repo}" "${chroot_distro}" | sudo tee "${chroot_base}/etc/apt/sources.list.d/ubports.list" >/dev/null
Synchronizing package index files and subsequent package upgrades can be performed using:
sudo sbuild-update --arch=${chroot_arch} -u -d ubports-${chroot_distro}
A build can be started from inside the debianized package source directory using:
sbuild --build=${chroot_arch} --host=${chroot_arch} -d ubports-${chroot_distro}
கட்டிடம் நிறைவு¶
If the build was successful, the binary packages will be placed in the parent directory. The build log will be placed inside ~/logs. In case the build failed, the chroot can be inspected using:
sudo sbuild-shell ${chroot_distro}
மேம்படுத்தல்கள்¶
தற்காலிக சேமிப்பு பதிவிறக்கங்கள்¶
In order to save bandwidth and time it is highly advisable to cache downloaded packages by using apt-cacher-ng. It can be installed with:
apt install apt-cacher-ng
Chroots then need to be configured so that apt inside the chroot uses apt-cacher-ng on the host as a proxy server:
printf 'Acquire::http { Proxy "http://localhost:3142"; }\n' | sudo tee "${chroot_base}/etc/apt/apt.conf.d/proxy" >/dev/null
தற்காலிக தொகுப்பு முடிவுகள்¶
ccache is a compiler cache which speeds up repeated compilation of the same source code by caching the resulting object files. The actual cache is stored on the host system and bind-mounted into sbuild chroots with a schroot hook:
ccache_dir=/var/cache/ccache-sbuild
sudo install --group=sbuild --mode=2775 -d "${ccache_dir}"
sudo env CCACHE_DIR="${ccache_dir}" ccache --max-size 4G
printf '%s %s none rw,bind 0 0\n' "${ccache_dir}" "${ccache_dir}" | sudo tee -a /etc/schroot/sbuild/fstab >/dev/null
In order to make use of ccache inside a sbuild chroot a wrapper script needs to be created:
cat >"${ccache_dir}/sbuild-ccache.sh" <<EOF
#!/bin/sh
export CCACHE_DIR=$ccache_dir
export CCACHE_UMASK=002
export CCACHE_COMPRESS=1
unset CCACHE_HARDLINK
export PATH=/usr/lib/ccache:\$PATH
exec "\$@"
EOF
chmod +x "${ccache_dir}/sbuild-ccache.sh"
In order to use this wrapper script the following line must be added to the configuration of a schroot chroot in /etc/schroot/chroot.d/:
command-prefix=/var/cache/ccache-sbuild/sbuild-ccache.sh
மேலும் வாசிப்பு¶
தொழில்நுட்ப விவரங்கள் sbuild (1) மற்றும் sbuild-createchroot (8) கையேடு பக்கங்கள் மற்றும்` டெபியன் விக்கி <https://wiki.debian.org/sbuild>`__.
குறுக்கு பில்டருடன் தொகுப்புகளை உருவாக்குதல்¶
கிராச் பில்டர் என்பது ஒரு ச்கிரிப்ட் ஆகும், இது டெபியன் தொகுப்புகளுக்கு ஒரு குறுக்கு கட்டமைப்பின் அமைவு மற்றும் பயன்பாட்டை தானியங்குபடுத்துகிறது. இலக்கு கருவியை விட உங்கள் டெச்க்டாப் கணினியில் குறியீடு தொகுப்பு ஏற்படுவதால் எந்தவொரு சாதனமும் கொண்ட டெவலப்பர்களுக்கு இது பொருத்தமானது. இது உபுண்டு தொடுதலில் கீழான மாற்றங்களை உருவாக்க பரிந்துரைக்கப்பட்ட வழியை கிராச்வில்டரை உருவாக்குகிறது.
Note
கிராச் பில்டருக்கு எல்எக்ச்.டி நிறுவப்பட்ட லினக்ச் வழங்கல் தேவைப்படுகிறது மற்றும் கிடைக்கக்கூடிய கன்ஃப்ளையர் கமாண்ட்செட் தேவைப்படுகிறது. வேறு வார்த்தைகளில் கூறுவதானால், நீங்கள் lxc கட்டளையை இயக்க முடியும். உங்கள் ஓச்டில் உபுண்டுவை இயக்குகிறீர்கள் என்றால், கிராச் பில்டர் உங்களுக்காக எல்எக்ச்.டி அமைப்பார்.
Start by installing Crossbuilder on your host:
cd ~
git clone https://github.com/ubports/crossbuilder.git
Crossbuilder is a shell script, so you don't need to build it. Instead, you will need to add its directory to your PATH environment variable, so that you can execute it from any directory:
echo 'export PATH="$HOME/crossbuilder:$PATH"' >> ~/.bashrc
# and add it to your current session:
source ~/.bashrc
Now that Crossbuilder is installed, we can use it to set up LXD:
crossbuilder setup-lxd
நீங்கள் எல்எக்ச்.டி.யைப் பயன்படுத்துவது இதுவே முதல் முறை என்றால், எல்லாம் முடிந்ததும் உங்கள் ஓச்டை மீண்டும் துவக்க வேண்டியிருக்கும்.
After LXD has been set up, a build for UBports based on Ubuntu 20.04 (Focal Fossa) using the arm64 architecture can be started from inside the debianized package source directory using:
distro=20.04
arch=arm64
crossbuilder --lxd-image="ubuntu:${distro}" --architecture="${arch}" build
For building against a different UBports release or architecture change distro and arch as needed.
கிராச் பில்டர் எல்எக்ச்.டி கொள்கலனை உருவாக்கி, மேம்பாட்டு படத்தைப் பதிவிறக்குங்கள், உங்கள் தொகுப்பு உருவாக்க சார்புகளை நிறுவி, தொகுப்பு உருவாக்கம் செய்யும். முதல் இரண்டு படிகள் (எல்எக்ச்.டி படத்தை உருவாக்குதல் மற்றும் சார்புகளைப் பெறுதல்) சில நிமிடங்கள் ஆகலாம், ஆனால் ஒரு புதிய தொகுப்புக்காக நீங்கள் கிராசில்டரை முதன்முதலில் தொடங்கும்போது மட்டுமே செயல்படுத்தப்படும்.
In order to deploy the newly built package on a local device (see ADB வழியாக செல் அணுகல் to learn more about connecting your device), you can use:
crossbuilder --lxd-image="ubuntu:${distro}" --architecture="${arch}" --password="password-or-0000-if-not-set" deploy
இப்போது, உங்கள் அறிவிலி களஞ்சியத்தில் மூலக் குறியீட்டை மாற்றும்போதெல்லாம், அதே மாற்றங்கள் கொள்கலனுக்குள் கிடைக்கும். அடுத்த முறை நீங்கள் மேலே உள்ள கிராச் பில்டர் கட்டளையைத் தட்டச்சு செய்யும் போது, மாற்றப்பட்ட கோப்புகள் மட்டுமே மீண்டும் கட்டப்படும்.
If the build dependencies have changed the following command can be used to update the container accordingly (distro and arch should be set as above):
crossbuilder --lxd-image="ubuntu:${distro}" --architecture="${arch}" dependencies
While crossbuilder does not create log files for the build process, the script utility may be used for that purpose:
script -c "crossbuilder --lxd-image=\"ubuntu:${distro}\" --architecture=\"${arch}\" build" build.log
When a build container is no longer needed it maybe removed using:
crossbuilder --lxd-image="ubuntu:${distro}" --architecture="${arch}" delete
அலகு சோதனைகள்¶
By default crossbuilder does not run unit tests; that's both for speed reasons, and because the container created by crossbuilder is not meant to run native (target) executables: the development tools (qmake/cmake, make, gcc, etc.) are all run in the host architecture, with no emulation (again, for speed reasons). However, qemu emulation is available inside the container, so it should be possible to run unit tests. You can do that by getting a shell inside the container:
crossbuilder --lxd-image="ubuntu:${distro}" --architecture="${arch}" shell
பின்னர் அலகு சோதனைகளைக் கண்டுபிடித்து அவற்றை இயக்கவும். எமுலேசன் சரியானதல்ல என்பதை அறிந்து கொள்ளுங்கள், எனவே சரியான சூழலில் இயங்கும்போது அவை வெற்றிபெறும்போது கூட சோதனைகள் தோல்வியடையும் என்பதற்கு மிகச் சிறந்த வாய்ப்பு உள்ளது. அந்த காரணத்திற்காக, கிராச் பில்டருடன் பணிபுரியும் போது அலகு சோதனைகளைப் பற்றி கவலைப்படாமல் இருப்பது புத்திசாலித்தனமாக இருக்கலாம், மேலும் குறுக்கு ஒப்பந்தம் செய்யாதபோது மட்டுமே அவற்றை இயக்கவும்.
கருவியில் உருவாக்குதல்¶
சிறிய மாற்றங்களை வளர்த்துக் கொள்வதற்கும் அவற்றை அறிவிலிடத்தட்ட நிகழ்நேரத்தில் சோதிப்பதற்கும் இது வேகமான மற்றும் எளிமையான முறையாகும். இருப்பினும், உங்கள் சாதன ஆதாரங்களைப் பொறுத்து, இந்த பாதையைப் பின்பற்ற முடியாது: உங்கள் ரூட் கோப்பு முறைமையில் போதுமான இலவச இடம் உங்களிடம் இல்லையென்றால், எல்லா தொகுப்பு உருவாக்க சார்புகளையும் நிறுவ முடியாது; தொகுக்கும் போது நீங்கள் ரேம் வெளியேறலாம்.
Warning
இந்த முறை குறைவாக உள்ளது. உபுண்டு தொடுதலின் கூறுகளை உருவாக்க தேவையான தொகுப்புகளை நிறுவ பல கருவிளில் போதுமான இலவச பட இடம் இல்லை. தொகுப்புகளை நிறுவுவது உங்கள் கருவியில் மென்பொருளை சேதப்படுத்தும் அபாயத்தைக் கொண்டுள்ளது, இது பயன்படுத்த முடியாதது. இது நடந்தால், உங்களால் முடியும் உபுண்டு டச் மீண்டும் நிறுவவும்.
இந்த எடுத்துக்காட்டில், நாங்கள் முகவரி-புத்தகம்-பயன்பாட்டை உருவாக்கி நிறுவுவோம். இங்கே காட்டப்பட்டுள்ள அனைத்து கட்டளைகளும் தொலைநிலை செல் மீது உங்கள் உபுண்டு டச் கருவியில் இயக்கப்பட வேண்டும்.
You can gain a shell on the device using ADB வழியாக செல் அணுகல் or பாஓடு வழியாக செல் அணுகல். Remount the root filesystem read-write to begin:
sudo mount / -o remount,rw
Next, install all the packages needed to rebuild the component you want to modify (the Contacts app, in this example):
sudo apt update
sudo apt build-dep address-book-app
sudo apt install fakeroot
Additionally, you probably want to install git in order to get your app's source code on the device and later push your changes back into the repository:
sudo apt install git
Once you're finished, you can retrieve the source for an app (in our example, the address book) and move into its directory:
git clone https://gitlab.com/ubports/core/address-book-app.git
cd address-book-app
Now, you are ready to build the package:
DEB_BUILD_OPTIONS="parallel=2 debug" dpkg-buildpackage -rfakeroot -b
The dpkg-buildpackage command will print out the names of generated packages. Install those packages with dpkg:
sudo dpkg -i ../<package>.deb [../<package2>.deb ...]
எவ்வாறாயினும், நீங்கள் அனைத்து தொகுப்புகளையும் நிறுவ வேண்டிய அவசியமில்லை என்பதை நினைவில் கொள்ளவும்: பொதுவாக, சாதனம் பயன்படுத்தும் குறியீடு இல்லாததால், -doc அல்லது dev என முடிவடையும் அனைத்து தொகுப்புகளையும் நீங்கள் தவிர்க்கலாம்.
அடுத்த படிகள்¶
இப்போது நீங்கள் வெற்றிகரமாக மாற்றங்களைச் செய்து உள்நாட்டில் சோதித்தீர்கள், அவற்றை கிதுபில் பதிவேற்ற தயாராக இருக்கிறீர்கள். மேம்பாட்டு தொகுப்புகளை உருவாக்க மற்றும் வழங்க யுபிதுறைமுகங்கள் தொஒ பயன்படுத்துவது பற்றி அறிய அடுத்த பக்கத்திற்குச் செல்லுங்கள்!