Doc: Update product name and intro/overview pages

    - Update product name to 'Qt for Device Creation'
    - Update index page and overview docs
    - Separate Boot to Qt section into its own page
    - Update documentation version
    - Link to Qt reference docs under doc.qt.io
    - Link to Android injection blog post

Change-Id: Ib8a35303285930b32b5c33995df8eeba9c1a978c
Reviewed-by: Eirik Aavitsland <eirik.aavitsland@theqtcompany.com>

1 files changed, 124 insertions, 84 deletions

diff --git a/src/doc/src/qtee-index.qdoc b/src/doc/src/qtee-index.qdoc
index 7228edf..f4b4757 100644
--- a/src/doc/src/qtee-index.qdoc
+++ b/src/doc/src/qtee-index.qdoc
@@ -18,19 +18,20 @@
 ****************************************************************************/
 
 /*!
-    \contentspage{index.html}{Qt Enterprise Embedded}
+    \contentspage{index.html}{Qt for Device Creation}
     \page index.html
     \nextpage qtee-overview.html
-    \title Qt Enterprise Embedded
+    \title Qt for Device Creation
 
-    \SDK provides a fully-integrated solution to get you started immediately
-    with software development on your embedded device with a tailored user
-    experience for embedded Linux and embedded Android. \SDK contains the tools
-    you need for fast, easy, and fully-integrated embedded device application
-    development. It comes with \B2Q, a light-weight UI stack for embedded
-    systems, and the Qt Creator integrated development environment (IDE) with
-    preconfigured build targets for hardware platforms, as well as an emulator
-    for testing the applications.
+    With commercially licensed Qt for device creation, you get a fully-integrated
+    solution to get you started immediately with software development on your
+    embedded device with a tailored user experience for embedded Linux and
+    embedded Android. Qt libraries can also be manually configured to other
+    operating systems or custom software stacks.
+
+    The Qt development environment for device creation consists of:
+
+    \include common.qdocinc overview-list
 
     \e{\b{IMPORTANT:} Make sure to follow the \l{Installation Guide}
     closely!}
@@ -38,7 +39,7 @@
     \section1 Contents
 
     \list
-        \li \l{About Qt Enterprise Embedded}
+        \li \l{Overview}
         \li \l{Installation Guide}
         \li \l{Supported Platforms}
         \li \l{Preparing Hardware}
@@ -71,66 +72,119 @@
 */
 
 /*!
-    \contentspage{index.html}{Qt Enterprise Embedded}
+    \contentspage{index.html}{Qt for Device Creation}
     \page qtee-overview.html
     \previouspage index.html
-    \nextpage qtee-installation-guide.html
+    \nextpage qtee-about-b2qt.html
 
-    \title About Qt Enterprise Embedded
+    \title Overview
 
-    \SDK has two main parts:
+    The development package that you get with Qt for device creation consists of:
 
-    \list
-        \li Development environment that is installed on a Linux development
-            desktop by using an online installer
-        \li \B2Q
-    \endlist
+    \include common.qdocinc overview-list
+
+    \section1 About Qt Development Libraries
+
+    \l {http://www.qt.io/}{Qt} is a full development framework designed to
+    streamline the creation of applications and user interfaces for desktop,
+    embedded, and mobile platforms. With Qt, you can reuse code efficiently
+    to target multiple platforms with one code base. The modular C++ class
+    library and development tools enable developers to create applications
+    for one platform and easily build and deploy on other platforms as well.
+
+    The Qt libraries provide high-level APIs for a large variety of both
+    non-GUI and GUI related functionality. For UI creation, Qt provides a
+    number of approaches: traditional C++, declarative UI design with
+    \l {Qt Quick} or HTML5/hybrid user interfaces with the \l {Qt WebEngine}
+    module.
+
+    For overview about Qt libraries see the \l {Qt reference documentation}.
 
     \section1 About the Development Environment
 
-    The development is done with the Qt Enterprise libraries and device
-    deployment can be done with one click directly from Qt Creator to a device
-    connected via USB. Alternatively, you can deploy the application locally
-    directly to the \B2Q Emulator that is running the full target software stack
-    as in the device.
+    The development environment is built around the Qt Creator IDE. Qt Creator
+    runs on all desktop platforms, but the embedded development environment is
+    currently supported only on 64-bit Linux desktop.
+
+    Device deployment can be done directly from the Qt Creator IDE to a device
+    connected via USB or local area network. The Qt Creator IDE is
+    pre-configured for devices running \B2Q but can also be manually configured
+    to build and deploy to custom embedded toolchains and devices.
 
-    As with any Qt based application, the same application can be deployed to
-    desktop and mobile OS targets as well.
+    Alternatively, you can deploy the application locally to the Emulator that
+    is running the same, full  software stack as the devices. As with any Qt
+    based application, the same application can be deployed to desktop and
+    mobile OS targets as well.
+*/
+
+/*!
+    \contentspage{index.html}{Qt for Device Creation}
+    \page qtee-about-b2qt.html
+    \previouspage qtee-overview.html
+    \nextpage qtee-installation-guide.html
 
-    \section1 About \B2Q
+    \title About Boot to Qt
 
     \e{\b{\B2Q}} is a light-weight, Qt-optimized, full software stack for
     embedded systems that is installed into the actual target device. This is
     done by flashing the device's memory card or internal memory directly with a
-    pre-built image that comes with the development environment.
+    pre-built image that comes with the online installer.
+    See the \l{Installation Guide} for details.
 
-    \B2Q supports two different operating systems:
+    \B2Q is ideal for the following use cases:
 
     \list
-        \li \b{\B2QA} where the software stack is based on the Android Kernel
-            (version 4.1 or higher) and selected  middleware. It includes a lean
-            software stack where Qt/QML replaces the top Java graphical layer
-            and removes the Zygote process layer as well the Android home screen
-            enabling better and faster development where modern UIs are at the
-            forefront.
-
-        \li \b{\B2QL} where the software stack is using the traditional embedded
-            Linux kernel built with the Yocto Poky reference system (Yocto 1.6
-            \e Daisy release). The Embedded Linux variant is designed for great
-            customization possibilities. It contains only components required in
-            the embedded device, resulting in smaller image sizes while keeping
-            valuable development tools available.
+        \li Evaluating Qt on real embedded environment using one of the provided
+            reference images.
+        \li Getting an immediately working embedded development environment up
+            and running as a starting point to production development. Later,
+            the stack can be customized to production with
+            \e Build-Your-Own-Stack tooling, including proprietary Yocto Project
+            recipes.
+        \li Creating embedded devices from off-the-shelf programmable Android
+            devices using \l {Android injection}.
     \endlist
 
-    Both versions have been tested and verified on a number of different
-    hardware configurations. \B2Q support is not limited to the devices used
-    as reference platforms, it can be made to run on a variety of hardware.
+    \image build-your-own-stack.png
+
+    Boot to Qt supports two different operating systems:
+
+    \b{\B2QL}\br
+    \B2QL is using the traditional embedded Linux
+    kernel built with the Yocto Poky reference system (Yocto 1.6 Daisy release).
+    The embedded Linux variant is designed for great customization possibilities.
+    It contains only components required in the embedded device, resulting in
+    smaller image sizes while keeping valuable development tools available.
+
+    \b{\B2QA}\br
+    The embedded Android stack provides an easy way to create a full embedded
+    device using off-the-shelf programmable Android devices,
+    making the device run stripped-down, Qt-optimized OS and middleware stack.
+    The device will then become an embedded device running Qt applications,
+    instead of running the Android OS with Android applications.
+
+    For just creating applications using the Qt libraries that run on the native
+    Android OS, see \l {Qt for Android} in Qt reference documentation.
+
+    \B2QA tries to strip down the Android stack to the
+    bare minimum, relying only on basic Linux features. The majority of the
+    Android stack, such as Dalvik virtual machine is not running in Boot to Qt,
+    resulting in faster startup times, lower memory consumption and overall
+    better performance.
+
+    The embedded Android stack can be installed into programmable Android
+    devices that are based on Android version 4.2 or higher.
 
-    \section1 Value-Add Components
+    Both versions of \B2Q have been tested and verified on a number of different
+    hardware configurations. Usage of \B2Q is not limited to the devices used as
+    \l {Supported Platforms}{reference platforms}, it can be made to run on a
+    variety of hardware.
 
-    In addition to the \B2Q stack and a comprehensive development environment,
-    \SDK comes with a set of components that bring new features and speed up the
-    creation of high-performing, modern UI embedded applications:
+    \section1 Additional Embedded Libraries and Value-Add Components
+
+    In addition to the Boot to Qt stack and a comprehensive development
+    environment, \SDK comes with a set of components that bring new features and
+    speed up the creation of high-performing, modern UI embedded applications:
 
     \list
         \li \l {Qt Virtual Keyboard} - complete virtual keyboard solution with
@@ -142,46 +196,32 @@
             assets.
         \li \l {Qt Charts} - UI Components for displaying visually pleasing
             charts, driven by static or dynamic data models.
-        \li \l {Qt Data Visualization} - UI Components for creating stunning
-            3D data visualizations.
+        \li \l {Qt Data Visualization} - UI Components for creating stunning 3D
+            data visualizations.
+        \li \l {Qt Quick 2D Renderer} - enables Qt Quick UIs on GPU-less
+            devices.
     \endlist
 
-    \section1 About Qt
+    \section1 Build-Your-Own-Stack Tooling
+
+    \B2QL is built using the tools and resources from the \l {Yocto Project},
+    and is based on Yocto's reference distribution (\e Poky). You can
+    use the same tools to build custom \B2Q images, and have control over
+    which packages are included in the build and how the software stack
+    is configured.
 
-    \l{http://www.qt.io}{Qt} is a full development framework with tools
-    designed to streamline the creation of applications and user interfaces
-    for desktop, embedded, and mobile platforms.
+    The process consist of three parts: Building the \B2Q image and the
+    external toolchain, building Qt libraries and add-ons, and configuring
+    Qt Creator for the new toolchain and custom image:
 
     \list
-        \li \b{Qt Framework} - intuitive APIs for C++
-            and CSS/JavaScript-like programming with
-            \b{Qt Quick} for rapid UI
-            creation
-        \li \b{Qt Creator IDE} - powerful cross-platform integrated development
-            environment, including UI designer tools and on-device debugging
-        \li \b{Tools and toolchains} - internationalization support, embedded
-            toolchains and more.
+        \li \l {Building Your Own Embedded Linux Image}
     \endlist
 
-    With Qt, you can reuse code efficiently to target multiple platforms
-    with one code base. The modular C++ class library and development tools
-    enable developers to create applications for one platform and easily
-    build and run to deploy also on other platforms.
-
-
-    \section1 \B2Q vs Qt for Android
-
-    \image b2qt-vs-qt-for-android.png
-
-    \e{\b{Qt for Android}} is a port of the Qt Framework to be used for application
-    development on the Android platform. Its purpose is to enable development
-    of applications that can run on Android devices. For developers writing
-    applications for the Android ecosystem, Qt for Android is the right choice.
+    \section1 Emulator
 
-    \b{\B2QA} tries to strip down the Android
-    stack to the bare minimum, relying only on basic Linux
-    features. The majority of the Android stack, such as
-    \e{Dalvik virtual machine} is not running in \B2Q,
-    resulting in faster startup times, lower memory consumption and
-    overall better performance.
+    The \l {Emulator Manual}{emulator} running a \B2Q image enables you to
+    test and debug applications in an environment practically identical to
+    that of the device, without having a real device connected to the
+    development host.
 */