V-Play Updates

V-Play Update Guide

After installing the V-Play SDK, you can receive updates with the Maintenance Tool. The Maintenance Tool is located at the installation directory of your V-Play SDK and is called MaintenanceTool.

Run this application and select Update components to check if any updates are available for the V-Play SDK.

You then see a list of packages for which an update is available. To update the packages, click Continue and then Update on the following screen. After all packages were downloaded and installed, you can close the Maintenance Tool by clicking the Done button.

Note: After you updated the SDK, you need to Clean your project so the updated V-Play version is used. To clean your project, open Qt Creator and select Clean Project from the Build menu. Afterwards you can run your project and the updated V-Play version is used.

With your V-Play signup, you get access to all V-Play updates for free. Some of the components are available exclusively for V-Play customers - to upgrade to a V-Play license click here.

Latest V-Play Release

v 2.18.2 (2018-11-07)

Highlights Blog Post: Release 2.18.2: MVC, MVVM, Flux with QML

V-Play 2.18.2 adds the latest Qt Creator 4.7, as well as many improvements and fixes. A new comprehensive guide helps you to structure your code, and separate logic from UI (MVC, MVVM, Flux).

V-Play 2.18.2 comes as a free update for all V-Play developers.

Update Now (New to V-Play? Get started here)

Highlights

  • V-Play now ships with Qt Creator version 4.7, giving you the latest stability improvements, fixes and new features.

    Update Note: For using the Qt Quick Compiler, which is the default for building in Release Mode with Qt Creator 4.7, it is required to list each qml file with an own entry in your resources.qrc. Otherwise, the compiler does not find the QML source files.

    To deactivate the QML compiler, you can use the CONFIG -= qtquickcompiler setting in your *.pro configuration. This only protects the QML resources and bundles them as assets within your binary. You can also skip a specific .qrc configuration with e.g. QTQUICK_COMPILER_SKIPPED_RESOURCES += bundle_only.qrc.

  • This V-Play update adds a new comprehensive developer guide: Separation of Model, View and Logic Code in your Qt App using QML

    The guide offers a best-practice solution how to separate model, view and logic components in your V-Play apps:

    A clean component architecture and data-flow helps to keep create readable code, avoids bugs and makes maintenance or refactoring easy.

    You can find the full example of the guide on GitHub:

    It is available as a project wizard template in Qt Creator as well:

    All V-Play Apps Examples and Demos now also use this best-practice solution.

New Features

  • Adds method FirebaseAuth::loginUserWithToken() to login a user with a custom authentication token.
  • You can now configure the Android status bar opacity with the Theme.colors.statusBarOpacity property.
  • Use AppButton::rippleEffect to control whether to show or hide a ripple effect for the button.

    This example hides the effect for a single button:

     import VPlayApps 1.0
    
     App {
    
       AppButton {
         text: "No Ripple Effect"
         onClicked: console.log("clicked")
         rippleEffect: false
       }
    
     }

    You can also use Theme.appButton.rippleEffect to change your app's default setting:

     import VPlayApps 1.0
    
     App {
    
       onInitTheme: {
         Theme.appButton.rippleEffect = false
       }
    
       AppButton {
         text: "No Ripple Effect"
         onClicked: console.log("clicked")
       }
    
     }

Improvements

  • Adds new property FirebaseConfig::name.

    You can use more than one FirebaseConfig instance by assigning a different unique name to each instance. These names are used for persistence and should be the same between app starts.

  • AppActivityIndicator now uses a RotationAnimator instead of a RotationAnimation to rotate the activity or loading indicator also if the UI thread is blocked. This allows a better user experience and more fluid UIs.

Fixes

  • Fixes a build error when using AdMob Plugin on Android using newer Android build system versions.
  • Fixes potential crashes when using callback functions with FirebaseDatabase.

Older V-Play Releases

v 2.18.1 (2018-09-13)

Highlights Blog Post: Release 2.18.1: JavaScript Promises for REST Services, Tinder Swipe Material Cards, QML QSortFilterProxyModel, QML YouTube Player

V-Play 2.18.1 introduces new components for embedding YouTube videos, for creating material cards and Tinder-like swipe cards. It also simplifies connecting to REST services, with the new HttpRequest component. V-Play 2.18.1 also adds several other fixes and improvements.

V-Play 2.18.1 comes as a free update for all V-Play developers.

Highlights

  • With the YouTubeWebPlayer component, you can now directly embed YouTube videos in your app with a simple QML API.

    The component uses a WebView internally and is based on the YouTube Iframe-Player API. To show how you can use the player in your app, you can have a look at the YouTube Player Demo App. It uses the YouTube Data API to browse playlists and videos of a configured channel.

    This is how you can use the player in QML:

     import VPlayApps 1.0
    
     App {
       NavigationStack {
         Page {
           title: "YouTube Player"
    
           YouTubeWebPlayer {
             videoId: "KQgqTYCfJjM"
             autoplay: true
           }
    
         }
       }
     }
  • New HttpRequest component for REST API connection, based on DuperAgent. This also includes Promises and image scaling/cropping features. You can find details and examples in the New Features section below and in the documentation.
  • New AppCard component to create material cards. You can also use Tinder-like swipe gesture with cards. With additional AppPaper and AppCardSwipeArea component, you can create fully custom card-like UI elements that can be swiped in a Tinder-like fashion.

New Features

  • The Page type now features two more signals appeared() and disappeared(). These signals fire when the page becomes active or inactive on a NavigationStack. They are convenience signals to avoid manual checks of Page::isCurrentStackPage.
     import VPlayApps 1.0
    
     App {
       NavigationStack {
         Page {
           title: "Page"
    
           // this code and manual checks of isCurrentStackPage are no longer required
           onIsCurrentStackPageChanged: {
             if(isCurrentStackPage)
               console.log("Page appeared")
             else
               console.log("Page disappeared")
           }
    
           // instead, you can use the new signals
           onAppeared: console.log("Page appeared")
           onDisappeared: console.log("Page disappeared")
         }
       }
     }

    This example shows how all the Page lifecycle events trigger when working with NavigationStack:

    • The user pushes a page to the stack. It thus becomes the active stack page and the Page::appeared signal fires.
    • After completion of the push operation, which caused the page to appear, the Page::pushed signal triggers.
    • The user now pushes another page to the stack. The Page::disappeared signal fires for the previously pushed page, as it is no longer visible on the stack.
    • By navigating back from the second to the first page, it becomes active again and the Page::appeared signal fires.
    • If the user now fully removes the page by again popping from the stack, the Page::disappeared signal fires.
    • After completion of the pop operation, which removed the page, the Page::popped signal triggers.

    Use this snippet to test the signals yourself:

     import VPlayApps 1.0
     import QtQuick 2.0
    
     App {
       // navigation stack for pages
       NavigationStack {
         initialPage: pageComponent
       }
    
       // page component
       Component {
         id: pageComponent
    
         Page {
           id: page
           title: "Page 1"
    
           // allow to push and pop pages dynamically
           Column {
             anchors.centerIn: parent
    
             // push additional page
             AppButton {
               text: "Push"
               onClicked: page.navigationStack.push(pageComponent, { title: "Page "+(navigationStack.depth + 1) })
             }
    
             // pop current page
             AppButton {
               text: "Pop"
               onClicked: page.navigationStack.pop()
             }
           }
    
           // handle lifecycle signals
           onAppeared: console.log(title+" appeared")
           onDisappeared: console.log(title+ " disappared")
           onPushed: console.log(title+ " pushed")
           onPopped: console.log(title+ " popped")
         }
       }
     }
  • You can now use the HttpRequest type as an alternative to the default XmlHttpRequest. It integrates DuperAgent, a QML clone of the fantastic SuperAgent library from VisionMedia.

    It is available as a singleton item for all components that use import VPlayApps 1.0:

     import VPlayApps 1.0
     import QtQuick 2.0
    
     App {
       Component.onCompleted: {
         HttpRequest
           .get("http://httpbin.org/get")
           .timeout(5000)
           .then(function(res) {
             console.log(res.status);
             console.log(JSON.stringify(res.header, null, 4));
             console.log(JSON.stringify(res.body, null, 4));
           })
           .catch(function(err) {
             console.log(err.message)
             console.log(err.response)
           });
       }
     }

    Similar to HttpRequest, which matches the DuperAgent Request type, other DuperAgent features are also available in V-Play with the Http prefix:

    The HttpRequest type also supports response caching of your requests out-of-the-box. To change cache behavior, you can use the HttRequest::config() method. It is also possible to change cache settings for individual requests:

     import VPlayApps 1.0
     import QtQuick 2.0
    
     App {
       Component.onCompleted: {
         HttpRequest
           .get("http://httpbin.org/get")
           .cacheSave(true) // cache the result of this request, regardless of global cache setting
           .cacheLoad(HttpCacheControl.PreferNetwork) // use network if possible, otherwise load from cache
           .then(function(res) {
             console.log(JSON.stringify(res.body))
           })
           .catch(function(err) {
             console.log(err.message)
           });
       }
     }
  • The DuperAgent package, which brings the HttpRequest type, also contains an implementation of the Promises/A+ specification and offers an API similar to the Promises API in ES2017. The Promise type works independently of DuperAgents's http features and does not require the Http prefix:
     import VPlayApps 1.0
     import QtQuick 2.0
    
     App {
       Component.onCompleted: {
         var p1 = Promise.resolve(3);
         var p2 = 1337;
         var p3 = HttpRequest
                 .get("http://httpbin.org/get")
                 .then(function(resp) {
                     return resp.body;
                 });
    
         var p4 = Promise.all([p1, p2, p3]);
    
         p4.then(function(values) {
             console.log(values[0]); // 3
             console.log(values[1]); // 1337
             console.log(values[2]); // resp.body
         });
       }
     }

    Promises are a convenient and flexible way to handle asynchronous aspects of your application.

  • You can now use SortFilterProxyModel to conveniently apply filter and sorting settings to your QML ListModel items:

    The following example shows the configured entries of the ListModel in a ListPage, and allows to sort the list using the name property:

     import VPlayApps 1.0
     import QtQuick 2.0
    
     App {
       // data model
       ListModel {
         id: fruitModel
    
         ListElement {
           name: "Banana"
           cost: 1.95
         }
         ListElement {
           name: "Apple"
           cost: 2.45
         }
         ListElement {
           name: "Orange"
           cost: 3.25
         }
       }
    
       // sorted model for list view
       SortFilterProxyModel {
         id: filteredTodoModel
         sourceModel: fruitModel
    
         // configure sorters
         sorters: [
           StringSorter {
             id: nameSorter
             roleName: "name"
           }]
       }
    
       // list page
       NavigationStack {
         ListPage {
           id: listPage
           title: "SortFilterProxyModel"
           model: filteredTodoModel
           delegate: SimpleRow {
             text: name
             detailText: "cost: "+cost
             style.showDisclosure: false
           }
    
           // add checkbox to activate sorter as list header
           listView.header: AppCheckBox {
             text: "Sort by name"
             checked: nameSorter.enabled
             updateChecked: false
             onClicked: nameSorter.enabled = !nameSorter.enabled
             anchors.horizontalCenter: parent.horizontalCenter
             height: dp(48)
           }
         } // ListPage
       } // NavigationStack
     } // App

    Please see the documentation of SortFilterProxyModel for more details and relevant types.

Improvements

  • Automatically remove focus from SearchBar text field if it gets invisible.

Fixes

  • Fixes a crash in the V-Play Live Client when using WikitudeArView.
  • When a device goes online, the App::isOnline property now becomes true only after a short delay. This is required, as otherwise the network adapter might not be ready yet, which can cause immediate network requests to fail.

v 2.18.0 (2018-08-08)

Highlights Blog Post: Release 2.18.0: Update to Qt 5.11.1 with QML Compiler and Massive Performance Improvements

V-Play 2.18.0 updates to Qt 5.11.1 and adds several improvements and fixes.

V-Play 2.18.0 comes as a free update for all V-Play developers.

Highlights

  • Update to Qt 5.11.1 with numerous big improvements, such as:
    • Major changes to QML compiler pipeline and QML engine, for improved performance on all platforms.
    • Qt Quick Compiler now also available in the free version, with CONFIG += qtquickcompiler
    • Improved performance and reduced GPU usage for Qt 3D.
    • New features for Qt Location and Maps, like turn-by-turn navigation.
    • Many improvements and fixes to core modules.

Improvements

  • WikitudeArView now properly rotates the camera image to device rotation on iOS.
  • WikitudeArView now supports live reloading of the HTML/JavaScript files with the V-Play Live Client.

Fixes

v 2.17.1 (2018-07-17)

Highlights Blog Post: Release 2.17.1: Use 3D with Live Reloading and Test Plugin Code Examples from Browser

V-Play 2.17.1 adds several improvements and fixes for V-Play components. It also includes a new app example, how to create custom listview delegates.

V-Play 2.17.1 comes as a free update for all V-Play developers.

New Features

  • New examples on how to work with list views. The examples cover how to make custom list item delegates (left) and make collapsible sub-sections within list items (right):

  • The plugin documentation now also includes code examples that you can test on your mobile phone directly from the browser, using the V-Play Web Editor.

    Here is an example how to display an ad banner with the AdMob plugin:

     import VPlayApps 1.0
     import VPlayPlugins 1.0
    
     App {
       NavigationStack {
         Page {
           title: "AdMob Banner"
    
           AdMobBanner {
             adUnitId: "ca-app-pub-3940256099942544/6300978111" // banner test ad by AdMob
             banner: AdMobBanner.Smart
           }
         }
       }
     }
  • App and GameWindow provide new properties to make the native keyboard handling on Android and iOS easier. You can use keyboardVisible and keyboardHeight to adapt your app layout when the keyboard is shown, like positioning controls above the keyboard.

    The following example displays a floating action button above the keyboard, that also adapts to size changes of the keyboard:

     import VPlayApps 1.0
     import QtQuick 2.7
    
     App {
       id: app
    
       // We unset the focus from the AppTextField after the keyboard was dismissed from the screen
       onKeyboardVisibleChanged: if(!keyboardVisible) textField.focus = false
    
       NavigationStack {
    
         Page {
           id: page
           title: qsTr("Keyboard Height")
    
           AppTextField {
             id: textField
             width: parent.width
             font.pixelSize: sp(25)
           }
    
           FloatingActionButton {
             // Add the keyboard height as bottom margin, so the button floats above the keyboard
             anchors.bottomMargin: app.keyboardHeight + dp(15)
             // We only show the button if the AppTextField has focus and the keyboard is expanded
             visible: textField.focus && app.keyboardHeight != 0
             icon: IconType.check
             backgroundColor: Theme.tintColor
             iconColor: "white"
             onClicked: textField.focus = false
           }
         }
       }
     }

Improvements

Fixes

v 2.17.0 (2018-06-12)

Highlights Blog Post: Release 2.17.0: Firebase Storage, Downloadable Resources at Runtime and Native File Access on All Platforms

V-Play 2.17.0 adds two new demos that show how to integrate C++ code with QML and add the new DownloadableResource and FileUtils items.

V-Play 2.17.0 comes as a free update for all V-Play developers.

Highlights

  • New Firebase Cloud Storage item to upload local files to the cloud:

    With the new FirebaseStorage item, you can upload files to the Firebase Cloud Storage. It uploads local files to the cloud file system and provides a public download URL.

    You can upload files like the following:

  • Download additional assets on demand at runtime with the new DownloadableResource item.
  • Have a look at two brand-new app demos that show how to integrate C++ with QML:
    • The first example shows the different forms of C++ and QML integration: signals, slots and properties. This example is the tutorial result from How to Expose a Qt C++ Class with Signals and Slots to QML.
    • The second example shows how to combine a C++ backend that provides the model data for a frontend created in QML. The data is displayed with QML with Qt Charts for both 2D and 3D charts.

New Features

  • The FileUtils item offers features for dealing with files from QML (open, copy, delete, etc).
  • You can now set a timeout for your V-Play Multiplayer games using the new property VPlayMultiplayer::socketTimeoutMs. This is useful to prevent clients with slow connections from slowing down the entire game.
  • Create feature-rich Augmented Reality (AR) apps & games with our new Wikitude Plugin.
  • Navigation drawer entries add setting the color of the text, icon and background in default, pressed and active state. To do so, the SimpleRow::style offers the additional selectedTextColor and activeBackgroundColor properties.

    In addition, the text and icon of tabs for TabControl or AppTabButton may now use a different color while being pressed. To take advantage of this feature in your app's navigation drawer entries and tabs, the Theme provides the following new settings:

     import VPlayApps 1.0
     import QtQuick 2.0
    
     App {
       onInitTheme: {
         Theme.colors.tintColor = "red"
    
         // drawer + item bg
         Theme.navigationAppDrawer.backgroundColor = "lightgrey"
         Theme.navigationAppDrawer.itemBackgroundColor = Theme.tintColor
         Theme.navigationAppDrawer.itemSelectedBackgroundColor = "orange"
         Theme.navigationAppDrawer.itemActiveBackgroundColor = "white"
    
         // item text
         Theme.navigationAppDrawer.textColor = "white"
         Theme.navigationAppDrawer.selectedTextColor = "black"
         Theme.navigationAppDrawer.activeTextColor = Theme.tintColor
    
         // tab text
         Theme.tabBar.titleColor = Theme.tintColor
         Theme.tabBar.titlePressedColor = "orange"
       }
    
       Navigation {
         navigationMode: navigationModeTabsAndDrawer
    
         NavigationItem {
           title: "Home"
           icon: IconType.home
           NavigationStack {
             Page { title: "Home" }
           }
         }
         NavigationItem {
           title: "Favorites"
           icon: IconType.star
           NavigationStack {
             Page { title: "Favorites" }
           }
         }
         NavigationItem {
           title: "Help"
           icon: IconType.question
           NavigationStack {
             Page { title: "Help" }
           }
         }
       }
     }
  • The V-Play Live Client now also supports Bluetooth, NFC and Qt Quick Pointer Handlers.
  • New property labelFontSize of the AppCheckBox to change its font size.
  • Network adapter selection in Live Server: Change the selected network adapter of the Live Server if your mobile Live Client is stuck in the "Connected" screen.

Improvements

Fixes

  • Fixes a potential crash and function evaluating warnings during object destruction if a Navigation and NavigationStack is used from within a Loader item.

v 2.16.1 (2018-05-08)

Highlights Blog Post: Release 2.16.1: Live Code Reloading with Custom C++ and Native Code for Qt

V-Play 2.16.1 features live code reloading with custom C++ and native code for V-Play and Qt projects.

iOS Bundle Identifier Migration

Starting with V-Play 2.16.1, the app's bundle identifier for iOS is set using the PRODUCT_IDENTIFIER setting in your *.pro project configuration. To adapt to the new setting perform the following steps:

1. Open your *.pro project file and add the following block:

 # configure the product's bundle identifier
 # this identifier is used for the app on iOS
 PRODUCT_IDENTIFIER = com.your.company.YourApp

where com.your.company.YourApp matches the CFBundleIdentifier setting of your existing Project-Info.plist configuration.

2. Open your Project-Info.plist in the ios subfolder and replace the value of CFBundleIdentifier with $(PRODUCT_BUNDLE_IDENTIFIER), so that it looks like the following:

 <key>CFBundleIdentifier</key>
 <string>$(PRODUCT_BUNDLE_IDENTIFIER)</string>

3. After running qmake, your iOS build uses the new setting.

Note: Make sure to transition your project to this new format, as otherwise app store build uploads from Xcode 9 might fail.

All V-Play Project Wizards already use the new project setting.

Highlights

  • Live Client Module: Live Code Reloading with Custom C++ and Native Code

    V-Play version 2.16.1 introduces the Live Client Module. You can use it to add QML live reloading features to your own application. This allows you to use custom C++ and native code together with live code reloading for QML and JavaScript. You can find a quick integration guide in the update blog post.

Improvements

Fixes

Older V-Play Releases

v 2.16.0 (2018-04-10)

Highlights Blog Post: Release 2.16.0: iPhone X Support and Runtime Screen Orientation Changes

V-Play 2.16.0 brings iPhone X support and runtime screen orientation changes.

V-Play Game Engine & V-Play Apps

Highlights
  • iPhone X Support for V-Play Apps

    The iPhone X comes with new UI challenges, as the screen is now bigger and includes reserved areas that hold native buttons or overlays. The V-Play Navigation components automatically adjust their style to match these new requirements. In addition, the Page::useSafeArea setting takes care of keeping your UI elements within the safe area of the screen.

    Alternatively, you can also disable the setting and manually align your content to the Page::safeArea item. The exact pixel insets of the screen are available with the NativeUtils::safeAreaInsets property.

  • iPhone X Support for V-Play Games

    To support existing games on devices with reserved screen areas, the Scene::useSafeArea setting keeps your scene content within the safe area. The Scene::gameWindowAnchorItem reflects this safe area of the screen.

    To provide the best look and experience, you can take advantage of the new Scene::fullWindowAnchorItem. You can then e.g. let your background fill the whole screen, without affecting other parts of the game.

    The exact pixel insets of the screen are available with the NativeUtils::safeAreaInsets property. If used within a Scene, keep in mind that these insets do not take scene-scaling into consideration.

  • Simulation of iPhone X for Debug Resolution Menu

    To speed up development, you can test your UI for iPhone X on Desktop without having to build and deploy for the iPhone Simulator.

    The Desktop simulation for iPhone X also covers the native safe area. You can quickly switch between different devices to see how your app looks like with and without safe area insets.

  • You can now set the preferred screen orientation at runtime from within QML code!

    To specify the global orientation you can use the new property NativeUtils::preferredScreenOrientation. E.g. to lock and unlock your app or game to portrait orientation, you can use the following lines of code:

     import VPlayApps 1.0
     import QtQuick 2.5
    
     App {
       NavigationStack {
         Page {
           title: "Orientation Lock"
    
           Column {
             AppButton {
               text: "Lock to portrait"
               onClicked: nativeUtils.preferredScreenOrientation = NativeUtils.ScreenOrientationPortrait
             }
             AppButton {
               text: "Reset default orientation"
               // Resets to the orientation defined in AndroidManifest.xml / Project-Info.plist
               onClicked: nativeUtils.preferredScreenOrientation = NativeUtils.ScreenOrientationDefault
             }
           }
         }
       }
     }

    You can also specify the orientation per page in apps, using Page::preferredScreenOrientation. Use this example code to show a page fixed to portrait mode:

     import VPlayApps 1.0
     import QtQuick 2.0
    
     App {
       id: app
    
       NavigationStack {
         id: stack
    
         Page {
           id: page
           title: "Screen orientation test"
    
           AppButton {
             text: "Push portrait page"
             onClicked: stack.push(portraitPage)
           }
         }
       }
    
       Component {
         id: portraitPage
    
         Page {
           id: page
           title: "Portrait page"
           preferredScreenOrientation: NativeUtils.ScreenOrientationPortrait
         }
       }
     }

    These properties only have an effect on iOS and Android and override the default screen orientation defined in your project's Project-Info.plist and AndroidManifest.xml.

  • New improved V-Play Live Server UI and new features.

Improvements
Fixes
  • Allows replacing the contentItem of AppTabButton with custom QML code, which threw an error before.
  • Solves performance issues with AnimatedSpriteVPlay and TexturePackerAnimatedSpriteVPlay on Windows.
  • Fixes a bug in VPlayGameNetwork where the user's selected country sometimes got reset on app restart.
  • Fixes a function parameter type issue for MouseJoint::getReactionForce() and MouseJoint::getReactionTorque().
  • NativeUtils::displayCameraPicker() now also supports targeting Android 7.0 and newer. Due to changes in the Android rules for app interaction, if your app uses a targetSdkVersion >= 24 in AndroidManifest.xml, it needs to use a content provider so the camera app can save the image to the app.

    For new projects created in Qt Creator, everything is already configured properly.

    If you have an existing project and are updating targetSdkVersion to 23 or greater, you need to add the following code to android/AndroidManifest.xml inside the <application> tag:

     <!-- file provider needed for letting external apps (like camera) write to a file of the app -->
     <provider
         android:name="android.support.v4.content.FileProvider"
         android:authorities="${applicationId}.fileprovider"
         android:exported="false"
         android:grantUriPermissions="true">
    
         <meta-data
             android:name="android.support.FILE_PROVIDER_PATHS"
             android:resource="@xml/file_paths"/>
     </provider>

    Additionally you need to create a file android/res/xml/file_paths.xml with the following contents:

     <?xml version="1.0" encoding="utf-8"?>
     <paths>
         <external-files-path name="images" path="Pictures"/>
     </paths>

    Finally, add the following dependencies to android/build.gradle:

     dependencies {
       ...
    
       compile 'com.android.support:support-core-utils:27.1.0'
       compile 'com.android.support:appcompat-v7:27.1.0'
     }
  • Fix a possible warning about missing getPrice()F method in log output when using Soomla Plugin.
  • The default AppButton::radius setting now applies App::dp() for the chosen ThemeAppButton::radius. Similar to other button settings, the border radius is therefore density independent from now on.
  • The VPlayMultiplayer::playerLeft() signal now triggers correctly when a player leaves the game.
  • Fix support for OneSignal push notifications on Android 8.0 devices.

v 2.15.1 (2018-02-21)

Highlights Blog Post: Release 2.15.1: Upgrade to Qt 5.10.1 & Qt Creator 4.5.1 | Firebase Improvements and New Live Code Reloading Apps

V-Play 2.15.1 updates to Qt 5.10.1 & Qt Creator 4.5.1 and adds new APIs for the Firebase Plugin.

V-Play Game Engine & V-Play Apps

Highlights
  • Update to Qt 5.10.1 which contains over 300 fixes and improvements.
  • Update to Qt Creator 4.5.1 which fixes several issues.
  • Firebase Plugin account configuration from QML. This makes Firebase setup easier and you can use multiple Firebase accounts from within the same app.
  • New callback functions for several FirebaseDatabase methods.
  • New V-Play Live Scripting mobile Apps for iOS and Android with project cache. You can now view your old projects on your device, without being connected to the Live Server.
New Features
Improvements
Fixes
  • Fix issue with failing QML imports in Qt Creator.
  • Fixes an issue where games would be always started in fullscreen mode while developing, if previously an app was run in iOS theme.
  • Fix App::isOnline and GameWindow::isOnline property on macOS Sierra and iOS 10.
  • Fix user position and location circle for AppMap with MapBoxGL plugin.

v 2.15.0 (2018-01-25)

Highlights Blog Post: Release 2.15.0: Upgrade to Qt 5.10 & Qt Creator 4.5 | Firebase Data Structures and Queries & Many Improvements

V-Play 2.15.0 updates to Qt 5.10

Qt 5.10 Update Note

  • Qt 5.10 introduced a new TabButton::icon property. The derived AppTabButton type, which also used a property with the same name, now offers the tabIcon property to provide the V-Play icon features.

V-Play Game Engine & V-Play Apps

Improvements
  • The update replaces the default icons used in PictureViewer, PullToRefreshHandler and VisibilityRefreshHandler to better match the platform styles. If required, you can still set your own icons with the available properties.

  • V-Play Live Client window always-on-top is now optional and can be disabled in Live Server.

  • V-Play Live Client now shows error log output directly in error screen if the Qml file could not be loaded.

  • Firebase Plugin: You can now read and write complex and nested objects and arrays in addition to primitive numbers, strings and booleans using FirebaseDatabase.

    Example:

     FirebaseDatabase {
       id: firebaseDb
    
       Component.onCompleted: getValue("public/path/to/my/object")
    
       onReadCompleted: {
         if(success) {
           //signal parameter "value" can be a nested object/array as read from your database
           console.debug("Read value " + value.subarray[3].subproperty.text)
         }
       }
     }
  • Firebase Plugin: You can now specify your query with the optional parameter queryProperties to the functions FirebaseDatabase::getValue() and FirebaseDatabase::getUserValue().

    Example:

     //use query parameter:
     firebaseDb.getValue("public/bigqueryobject", {
                           orderByKey: true,  //order by key before limiting
                           startAt: "c",      //return only keys alphabetically after "c"
                           endAt: "m",        //return only keys alphabetically before "m"
                           limitToFirst: 5,   //return only first 5 sub-keys
                         })

    See more details about the available query parameters at the documentation of FirebaseDatabase::getValue().

  • Firebase Plugin: You can now access the logged in user's ID token using the new FirebaseAuth::userToken property.
  • Firebase Plugin: You can now disable on-disk cache by using the new FirebaseDatabase::persistenceEnabled property.
Fixes
  • Fixes a Navigation issue that affected the usage of the source property for NavigationItem.
  • If the Navigation is created with a Loader that uses the asynchronous setting, the Android menu button displays correctly again.
  • VPlayMultiplayer::leaveGame() requests are now only sent when in lobby, room or game state. The function does not interfere with ongoing joinLobby requests anymore.
  • Fixes the vertical alignment of SimpleRow's disclosure indicator.
  • Fixed a SyncedStore issue which caused syncing to fail in some cases.

V-Play Releases before 2018

List of older releases: V-Play Updates (Older Releases)

Voted #1 for:

  • Easiest to learn
  • Most time saving
  • Best support

Develop Cross-Platform Apps and Games 50% Faster!

  • Voted the best supported, most time-saving and easiest to learn cross-platform development tool
  • Based on the Qt framework, with native performance and appearance on all platforms including iOS and Android
  • Offers a variety of plugins to monetize, analyze and engage users
FREE!
create apps
create games
cross platform
native performance
3rd party services
game network
multiplayer
level editor
easiest to learn
biggest time saving
best support