To build from the command line, start the Visual Studio 2015 (or 2017, 2019, etc.) Command Prompt and go (cd) to the directory where you have extracted the POCO C Libraries sources. Then, simply start the buildwin.cmd script and pass as argument the version of Visual Studio (140, 150, 160). You can customize what is being built by buildwin. Flutter has a strong command line interface. We can create a binary of the app by using the command line tools and following the instructions in Flutter documentation for building and releasing Android and iOS apps. On top of this, Flutter has officially documented the deployment process with fastlane here. Analysis & result.

1. Downloading Command Line Tools For Xcode Homebrew Download
2. Downloading Command Line Tools For Xcode Homebrew
3. Homebrew Installing Command Line Tools For Xcode

This section describes how to set up your local work environment to build the Android source files. You must use Linux or macOS; building under Windows is not currently supported.

For an overview of the entire code-review and code-update process, see Life of a Patch.

Note: All commands in this site are preceded by a dollar sign ($) to differentiate them from output or entries within files. You may use the Click to copy feature at the top right of each command box to copy all lines without the dollar signs or triple-click each line to copy it individually without the dollar sign.

Choosing a branch

Some requirements for the build environment are determined by the version of the source code that you plan to compile. For a full list of available branches, see Build Numbers. You can also choose to download and build the latest source code (called master), in which case you simply omit the branch specification when you initialize the repository.

After selecting a branch, follow the appropriate instructions below to set up your build environment.

Setting up a Linux buildenvironment

These instructions apply to all branches, including master.

The Android build is routinely tested in house on Ubuntu LTS (14.04) and Debian testing. Most other distributions should have the required build tools available.

For Gingerbread (2.3.x) and higher versions, including the master branch, a 64-bit environment is required. Older versions can be compiled on 32-bit systems.

Note: See Requirements for the complete list of hardware and software requirements, then follow the detailed instructions for Ubuntu and macOS below.

Installing required packages(Ubuntu 18.04)

You need a 64-bit version of Ubuntu.

Installing required packages(Ubuntu 14.04)

You need a 64-bit version of Ubuntu (14.04 is recommended).

Note: To use SELinux tools for policy analysis, also install the python-networkx package.Note: If you're using LDAP and want to run ART host tests, also install the libnss-sss:i386 package.

Installing required packages (Ubuntu 12.04)

You may use Ubuntu 12.04 to build older versions of Android. Version 12.04 isn't supported on master or recent releases.

Downloading Command Line Tools For Xcode Homebrew Download

Installing required packages (Ubuntu 10.04-11.10)

Building on Ubuntu 10.04-11.10 is no longer supported, but may be useful for building older releases of AOSP.

On Ubuntu 10.10:

On Ubuntu 11.10:

Configuring USB access

Install a community-maintained default set of udev rules for all Android devices by following the instructions to Set up a device for development.

Using a separate outputdirectory

By default, the output of each build is stored in the out/ subdirectory of the matching source tree.

On some machines with multiple storage devices, builds are faster when storing the source files and the output on separate volumes. For additional performance, the output can be stored on a file system optimized for speed instead of crash robustness, because all files can be regenerated if the file system is corrupted.

To set this up, export the OUT_DIR_COMMON_BASE variable to point to the location where your output directories will be stored.

The output directory for each separate source tree is named after the directory holding the source tree. For instance, if you have source trees /source/master1 and /source/master2 and if OUT_DIR_COMMON_BASE is set to /output, the output directories are /output/master1 and /output/master2.

Avoid having multiple source trees stored in directories that have the same name, as the source trees would end up sharing an output directory, with unpredictable results. This is only supported on Jelly Bean (4.1) and higher, including the master branch.

Setting up a macOS build environment

In a default installation, macOS runs on a case-preserving but case-insensitive file system. This type of file system isn't supported by Git and causes some Git commands (such as git status) to behave abnormally. Because of this, we recommend that you always work with the AOSP source files on a case-sensitive file system. This can be done fairly easily using a disk image, discussed below.

When the proper file system is available, building the master branch in a modern macOS environment is straightforward. Earlier branches require some additional tools and SDKs.

Creating a case-sensitive diskimage

You can create a case-sensitive file system within your existing macOS environment using a disk image. To create the image, launch Disk Utility and select New Image. A size of 250 GB is the minimum to complete the build; more space is best for future growth. Using sparse images saves space while allowing growth as needed. Select case sensitive, journaled as the volume format.

You can also create the file system from a shell with the following command:

This creates a .dmg.sparseimage file which, when mounted, acts as a drive with the required formatting for Android development.

If you need a larger volume later, you can resize the sparse image with the following command:

For a disk image named android.dmg.sparseimage stored in your home directory, you can add helper functions to ~/.bash_profile:

• To mount the image when you execute mountAndroid:
• To unmount it when you execute umountAndroid:

After you've mounted the android volume, you do all your work there. You can eject it (unmount it) just as you would an external drive.

Installing Xcode and other packages

1. Install the Xcode command line tools: For older versions of macOS (10.8 or lower), you must install Xcode from the Apple developer site. If you aren't registered as an Apple developer, you must create an Apple ID to download.
2. Install either MacPorts or Homebrew for package management.
3. Ensure that the associated directory is in your path within your ~/.bash_profile file:
   1. MacPorts - /opt/local/bin must appear before/usr/bin:
   2. Homebrew - /usr/local/bin:
   3. For MacPorts, issue:
   4. For Homebrew, issue:

   Setting a file descriptor limit

   On macOS, the default limit on the number of simultaneous open file descriptors is too low and a highly parallel build process may exceed this limit. To increase the cap, add the following lines to your ~/.bash_profile:

   Next: Download the source

   Your build environment is good to go! Proceed to downloading the source.

• Contents
  • Setting Up The POCO C++ Libraries
    • External Dependencies
  • Some other Hints:

Welcome

Thank you for downloading the POCO C++ Libraries and welcome to the growing community of POCO C++ Libraries users. This document will help you in getting a smooth ride while installing and setting up the POCO C++ Libraries and going the first steps with the software.

Setting Up The POCO C++ Libraries

The POCO C++ Libraries are delivered in full source code only. Due to the large number of possible build configurations, no binary releases are provided from the project maintainers. This means that you have to build the libraries and tools before you can use them the first time.

Note: There are binary releases available as installation packages for various operating systems (e.g., Debian Linux, Ubuntu Linux, OpenBSD, OpenWRT, etc.). However, these packages are not maintained by the core team and may not always be up to date.

Up-to-date Conan packages are available via Bintray.

Source Code Distribution Format

The source code for the POCO C++ Libraries is delivered in a ZIP file for Windows users and/or in a compressed TAR file (.tar.gz or .tar.bz2) for Unix/Linux users. Both archives contain the same files, the only difference is that all text files in the ZIP files have line endings suitable for Windows (CR-LF), while the text files in the TAR file have line endings suitable for Unix/Linux (LF only). All libraries and tools follow a common convention for the directory layout. This directory layout is shown below.

Depending on what package you have downloaded (Basic or Complete Edition), there may be other libraries as well (such as Data, Crypto, NetSSL_OpenSSL and Zip).

External Dependencies

The following libraries require third-party software (header files and libraries) being installed to build properly:

• NetSSL_OpenSSL and Crypt require OpenSSL.
• Data/ODBC requires ODBC (Microsoft ODBC on Windows, unixODBC or iODBC on Unix/Linux)
• Data/MySQL requires the MySQL client.

OpenSSL

Unix/Linux

Most Unix/Linux systems already have OpenSSL preinstalled, or OpenSSL can be easily installed using the system’s package management facility. For example, on Ubuntu (or other Debian-based Linux distributions) you can type

to install the necessary packages. If your system does not have OpenSSL, please get it from http://www.openssl.org/ or another source. You do not have to build OpenSSL yourself — a binary distribution is fine.

On macOS, it's recommended to install OpenSSL via Homebrew.

Windows

On Windows, there are three options:

• Use POCO pre-built OpenSSL binaries (simplest and recommended)
• Build OpenSSL using scripts from POCO distribution package
• Use a third-party pre-built OpenSSL

POCO pre-built OpenSSL binaries

OpenSSL binaries (version 1.1.0) built with Visual Studio 2013 are available for download.

In case you are using pre-built binaries, please make sure to copy the entire directory to C:%POCO_BASE%openssl.

Or, %POCO_BASE%openssl directory can be deleted (if existing) and POCO openssl github repository cloned into it:

All libraries are located in their proper folders (eg. win64/bin/debug/), and all are named accordingly (libcrypto[mt[d]] and libssl[mt[d]]).

Build OpenSSL using scripts from POCO distribution package

Alternatively, if you choose to build your own OpenSSL, POCO C++ Libraries distribution package comes with scripts to build OpenSSL on Windows operating system. This requires Windows PowerShell.

Usage:

Example: Building OpenSSL 1.1.0, DLL release build for x64 with Visual Studio 2015:

The above command will download all the necessary packages (perl, nasm, etc) and build OpenSSL in C:%POCO_BASE%opensslbuild directory; the built OpenSSL binaries can be linked from EXEs and DLLs built with Visual Studio 2015 to 2019.

Pre-generated POCO Visual Studio projects are configured to use headers and libraries from C:%POCO_BASE%opensslbuild directory.

Use a third-party pre-built OpenSSL

Yet another way to install OpenSSL on Windows is to use a binary (prebuild) release, for example the one from Shining Light Productions that comes with a Windows installer (http://www.slproweb.com/products/Win32OpenSSL.html). Depending on where you have installed the OpenSSL libraries, you might have to edit the build script (buildwin.cmd), or add the necessary paths to the INCLUDE and LIB environment variables. You might also have to edit the project settings if the names of the OpenSSL libraries from your build differ from the names used in the project files.

ODBC

The Data library requires ODBC support on your system if you want to build the ODBC connector (which is the default). On Windows platforms, ODBC should be readily available if you have the Windows SDK installed. On Unix/Linux platforms, you can use iODBC or unixODBC. On Linux, use your distribution's package management system to install the necessary libraries and header files. For example, on Ubuntu, type

to install the iODBC library and header files.

The Data/ODBC and Data/MySQL Makefiles will search for the ODBC and MySQL headers and libraries in various places. Nevertheless, the Makefiles may not be able to find the headers and libraries. In this case, please edit the Makefile in Data/ODBC and/or Data/MySQL accordingly.

MySQL Client

The Data library requires the MySQL client libraries and header files if you want to build the MySQL connector (which is the default). On Windows platforms, use the MySQL client installer to install the necessary files. On Unix/Linux platforms, use the package management system of your choice to install the necessary files. Alternatively, you can of course build MySQL yourself from source.

Building using CMake

As an alternative to the platform specific Makefiles and Solutions, CMake can be used to do build POCO C++ Libraries on any platform with any compiler. CMake is a meta build system and it generate native makefiles and workspaces that can be used in the compiler environment of your choice. For a quick overview see http://cgold.readthedocs.io/en/latest/overview/cmake-can.html

POCO C++ Libraries requires CMake 3.2 or higher. Static binaries for many platforms can be downloaded from http://www.cmake.org/

CMake supports out of source builds and this is the recommended way to build POCO C++ Libraries using CMake.

Assuming the POCO C++ Libraries source is located in /path/to/poco directory and you like to build POCO C++ Libraries just type the following commands (Command parameters are all the same on any platform).

This will build POCO C++ Libraries in a subdirectory poco-build. All files produced during build are located in this directory.

Some cmake basic parameters:

For Makefile (default on Unix systems) and Ninja based build system (and all other single-configuration generators), there exists following build types: * Debug * Release * RelWithDebInfo (Release build with Debug infos) * MinSizeRel (Release build with size optimisation)

As default, POCO is build RelWithDebInfo. See cmake output like:

You can change this with following parameter: CMAKE_BUILD_TYPE=....

For example to build with debug symbols:

For more infos see https://cmake.org/cmake/help/latest/variable/CMAKE_BUILD_TYPE.html?highlight=cmake_build_type

For multi-configuration generators, (like Visual Studio and Xcode), CMAKE_BUILD_TYPE is ignored!

For these you should set build type at build time:

For example to build with debug symbols:

Installation path of Poco is as defaults to /usr/local on UNIX and c:/Program Files/Poco on Windows.

You can change the path with following parameter: CMAKE_INSTALL_PREFIX=....

For example to install in /usr:

This will install the poco libs in /usr/lib and the binaries in /usr/bin etc.

See also cmake output like:

For more infos see https://cmake.org/cmake/help/latest/variable/CMAKE_INSTALL_PREFIX.html?highlight=cmake_install_prefix

To set libraries type, you can use following parameter: BUILD_SHARED_LIBS=[ON/OFF]

As default, Poco build dynamic libraries, see cmake output like:

To set some additional compiler flags, you can use following parameters:

* CMAKE_C_FLAGS For C compiler * CMAKE_CXX_FLAGS For C++ compiler

For example:

For default compile flags, see cmake output like:

For more infos see https://cmake.org/cmake/help/latest/variable/CMAKE_LANG_FLAGS.html#variable:CMAKE_%3CLANG%3E_FLAGS

To use the compiler of your choice, you can use following paramters:

• CMAKE_C_COMPILER C compiler
• CMAKE_CXX_COMPILER C++ compiler

For example to use the clang compiler, execute following cmake command:

To cross compile POCO C++ Libraries for another architecture/device you should have a cmake toolchain file and execute following command:

See https://cmake.org/cmake/help/latest/manual/cmake-toolchains.7.html for more information.

Poco special build parameters:

POCO C++ Libraries allows you to set some build time options. As an example: to disable the SevenZip support type the following command:

Here an overview of POCO build options:

• ENABLE_XML Set to OFF|ON (default is ON) to build XML support library
• ENABLE_JSON Set to OFF|ON (default is ON) to build JSON support library
• ENABLE_NET Set to OFF|ON (default is ON) to build Net support library
• ENABLE_NETSSL Set to OFF|ON (default is ON) to build NetSSL support library (Need installed openssl libraries)
• ENABLE_CRYPTO Set to OFF|ON (default is ON) to build Crypto support library (Need installed openssl libraries)
• ENABLE_DATA Set to OFF|ON (default is ON) to build Data support library
• ENABLE_DATA_SQLITE Set to OFF|ON (default is ON) to build Data SQlite support library
• ENABLE_DATA_MYSQL Set to OFF|ON (default is ON) to build Data MySQL or MariaDB support library (Need installed MySQL or MariaDB client libraries)
• ENABLE_DATA_POSTGRESQL Set to OFF|ON (default is ON) to build SQL PosgreSQL support library (Need installed PostgreSQL client libraries)
• ENABLE_DATA_ODBC Set to OFF|ON (default is ON) to build Data ODBC support library (Need installed ODBC libraries)
• ENABLE_MONGODB Set to OFF|ON (default is ON) to build MongoDB support library
• ENABLE_REDIS Set to OFF|ON (default is ON) to build Redis support library
• ENABLE_PDF Set to OFF|ON (default is OFF) to build PDF support library
• ENABLE_UTIL Set to OFF|ON (default is ON) to build Util support library
• ENABLE_ZIP Set to OFF|ON (default is ON) to build Zip support library
• ENABLE_SEVENZIP Set to OFF|ON (default is OFF) to build SevenZip support library
• ENABLE_APACHECONNECTOR Set to OFF|ON (default is ON) to build ApacheConnector support library (Need installed apache and apr libraries)
• ENABLE_CPPPARSER Set to OFF|ON (default is OFF) to build C++ parser
• ENABLE_ENCODINGS Set to OFF|ON (default is ON) to build with Encodings
• ENABLE_ENCODINGS_COMPILER Set to OFF|ON (default is OFF) to build Encodings Compiler
• ENABLE_PAGECOMPILER Set to OFF|ON (default is ON) to build PageCompiler
• ENABLE_PAGECOMPILER_FILE2PAGE Set to OFF|ON (default is ON) to build File2Page
• ENABLE_POCODOC Set to OFF|ON (default is OFF) to build Poco Documentation Generator
• ENABLE_TESTS Set to OFF|ON (default is OFF) to build Unit tests
• ENABLE_LONG_RUNNING_TESTS Set to OFF|ON (default is ON) to use long running test
• POCO_UNBUNDLED Set to OFF|ON (default is OFF) to control linking dependencies as external

Windows only parameter:

• POCO_MT Set to OFF|ON (default is OFF) to control build of POCO as /MT instead of /MD
• ENABLE_MSVC_MP Set to OFF|ON (default is OFF) to control parallel build of POCO with MSVC
• ENABLE_NETSSL_WIN Set to OFF|ON (default is OFF) to build NetSSL support library(Need installed openssl libraries For Windows only)

You can also see and enable or disable available options execute following command:

or for console only:

POCO C++ Libraries options are prefixed with ENABLE_. (This will be changed in POCO 2.x.x to POCO_)

Third-party library location

If a third-party library is not installed in a default location, cmake will fail to run. There exists following parameters to set additional search paths for cmake to find third-party libraries:

To find PostgreSQL:

• PostgreSQL_ROOT_DIR - Set root installation path where to find include path and libraries of PostgreSQL or
• PostgreSQL_ROOT_INCLUDE_DIRS - Set include paths where to find PostgreSQL headers
• PostgreSQL_ROOT_LIBRARY_DIRS - Set library paths where to find PostgreSQL libraries

To find ODBC:

• ODBC_ROOT_DIR - Set root installation path where to find include path and libraries of ODBC or
• ODBC_ROOT_INCLUDE_DIRS - Set include paths where to find ODBC headers
• ODBC_ROOT_LIBRARY_DIRS - Set library paths where to find ODBC libraries

To find MySQL or MariaDB:

• MYSQL_ROOT_DIR - Set root installation path where to find include path and libraries of MySQL or MariaDB or
• MYSQL_ROOT_INCLUDE_DIRS - Set include paths where to find MySQL or MariaDB headers
• MYSQL_ROOT_LIBRARY_DIRS - Set library paths where to find MySQL or MariaDB libraries

• APRUTIL_ROOT_DIR - Set root installation path where to find include path and libraries of apr util or
• APRUTIL_ROOT_INCLUDE_DIRS - Set include paths where to find apr util headers
• APRUTIL_ROOT_LIBRARY_DIRS - Set library paths where to find apr util libraries

• APR_ROOT_DIR - Set root installation path where to find include path and libraries of apr or
• APR_ROOT_INCLUDE_DIRS - Set include paths where to find apr headers
• APR_ROOT_LIBRARY_DIRS - Set library paths where to find apr libraries

• APACHE2_ROOT_DIR - Set root installation path where to find include path and libraries of apache2 or
• APACHE2_ROOT_INCLUDE_DIRS - Set include paths where to find apache2 headers

For example set installation path of MySQL:

or

How to use POCO in your cmake project:

To use POCO C++ Libraries in your cmake project, add following line in your project for example to use crypto:

If you get an error like 'By not providing 'FindPoco.cmake', then you should set CMAKE_PREFIX_PATH to the installation directory of your POCO C++ Libraries. For example:

Some other Hints:

For a faster build, use ninja as build system. See https://ninja-build.org/ For example on Ubuntu execute following commands:

This install ninja command. To use ninja-build execute following cmake commands:

See https://cmake.org/cmake/help/latest/manual/cmake-generators.7.html for other generators.

To enable verbose output from Makefile builds, execute following cmake commands:

Some more infos about cmake see:

$ cmake —help-full https://cmake.org/cmake/help/latest/ http://cgold.readthedocs.io/en/latest/index.html

Building On Windows

Microsoft Visual Studio 2015 or newer is required to build the POCO C++ Libraries on Windows platforms. Solution and project files for all versions are included. 64-bit (x64) builds are supported as well. You can either build from within Visual Studio (Build->Batch Build->Select All;Rebuild) or from the command line. To build from the command line, start the Visual Studio 2015 (or 2017, 2019, etc.) Command Prompt and go (cd) to the directory where you have extracted the POCO C++ Libraries sources. Then, simply start the buildwin.cmd script and pass as argument the version of Visual Studio (140, 150, 160). You can customize what is being built by buildwin.cmd by passing appropriate command line arguments to it. Call buildwin.cmd without arguments to see what is available. Build environment is set up by the buildwin.cmd; to avoid build problems, it is recommended to start the build in a clean command prompt console, i.e. not in the one provided by Visual Studio for 32/64-bit builds (although those will work fine if used appropriately for the right 32/64-bit build type).

To disable certain components (e.g., NetSSL_OpenSSL or Data/MySQL) from the build, edit the text file named components in the distribution root directory and remove or comment the respective lines.

Certain libraries, like NetSSL_OpenSSL, Crypto or Data/MySQL have dependencies to other libraries. Since the build script does not know where to find the necessary header files and import libraries, you have to either add the header file paths to the INCLUDE environment variable and the library path to the LIB environment variable, or you'll have to edit the buildwin.cmd script, where these environment variables can be set as well.

In order to run the test suite and the samples, the top-most bin directory containing the resulting shared libraries must be in the PATH environment variable.

Building On Unix/Linux/macOS

For building on Unix platforms, the POCO C++ Libraries come with their own build system. The build system is based on GNU Make 3.80 (or newer), with the help from a few shell scripts. If you do not have GNU Make 3.80 (or newer) installed on your machine, you will need to download it from http://directory.fsf.org/devel/build/make.html and build and install it prior to building the POCO C++ Libraries.

You can check the version of GNU Make installed on your system with

or

Once you have GNU Make up and running, the rest is quite simple. To extract the sources and build all libraries, testsuites and samples, simply

Downloading Command Line Tools For Xcode Homebrew

For help, either invoke

Alternatively, you can read the configure script source for a list of possible options. For starters, we recommend <[--no-tests and <[--no-samples, to reduce build times. On a multicore or multiprocessor machine, use parallel makes to speed up the build (make -j4).

Once you have successfully built POCO, you can install it to <*/usr/local (or another directory specified as parameter to configure <[--prefix=<path>):

You can omit certain components from the build. For example, you might want to omit Data/ODBC or Data/MySQL if you do not have the corresponding third-party libraries (iodbc or unixodbc, mysqlclient) installed on your system. To do this, use the <[--omit argument to configure:

IMPORTANT: Make sure that the path to the build directory does not contain symbolic links. Furthermore, on macOS (or other systems with case insensitive filesystems), make sure that the characters in the path have the correct case. Otherwise you'll get an error saying 'Current working directory not under $PROJECT_BASE.'.

Building On QNX Neutrino

For QNX Neutrino, the Unix build system (see the instructions above) is used. You can use the build system to cross-compile for a target platform on a Solaris or Linux host. Unfortunately, the Cygwin-based Windows host environment has some major quirks that prevent the build system from working there. You can also use the build system on a self-hosted QNX system. The default build configuration for QNX (found in build/config/QNX) is for a self-hosted x86 platform. To specify another target, edit the CCVER setting in the build configuration file. For example, to compile for a PowerPC target, specify CCVER=3.3.1,gcc_ntoppcbe.

Service Pack 1 for QNX Neutrino 6.3 must be installed, otherwise compiling the Foundation library will fail due to a problem with the <*<list> header in the default (Dinkumware) C++ standard library.

When building on QNX, you might want to disable NetSSL_OpenSSL, Crypto and some Data connectors, unless you have the necessary third party components available:

Tutorials And Sample Code

Introductory documentation consisting of various documents and tutorials in the form of slide decks can be found at the POCO C++ Libraries Documentation page.

Sample applications demonstrating the various features of the POCO C++ Libraries are delivered with the source code. Every library's source code directory has a samples directory containing various sample applications.

When building the sample applications on platforms using the gmake-based build system, please make sure that the environment variable POCO_BASE contains the path to the POCO C++ Libraries source tree root directory.

Creating Your Own POCO-based Applications

The best way to create your first POCO-based application is by copying one of the sample projects and making the desired changes. Examine the project files and Makefiles to see what compiler options must be set for your specific platform.

Homebrew Installing Command Line Tools For Xcode

Applied Informatics C++ Libraries and Tools 1.10.1-all
Copyright © 2021, Applied Informatics Software Engineering GmbH and Contributors