I wanted to update all of you on XAF's Mobile UI (CTP) we first publicly announced in late April (XAF Goes Mobile: CTP Version Ships with v15.2.9). To refresh your memory, this new feature allows you to create iOS, Android and Windows Phone apps alongside its Windows and Web app counterparts. XAF's mobile apps reuse the database, as well as certain aspects of the data model, application logic and UI settings of existing XAF applications.

In the last couple of months, we've received some great feedback from early adopters (thank you very much for all your support and assistance) and as a result, we've been hard at work improving our implementation. At this stage, the mobile platform is still in CTP and is not yet ready for production use due to known issues, unsupported scenarios and a somewhat long TODO list. Additionally, certain aspects of XAF Mobile's functionality and API are likely to change...

In this blog post, I'd like to describe the primary changes made between our last set of iterations.

XAF Solution Wizard integration

With v16.1.4, you can create XAF Mobile apps via our Solution Wizard - invoked via the File | New | Project... menu in Visual Studio:

The wizard's UI is automatically updated based on selected options (Entity Framework, AuthenticationActiveDirectory and Client Side Security UI-level items are filtered out, because they are unsupported). See more wizard screenshots here: one, two, three, four, five.

Simplified Navigation

Business classes marked with the DefaultClassOptions attribute and residing in the Default navigation group appear in the mobile navigation automatically - without the need to set MobileVisible = True for each corresponding View via the Model Editor. This should simplify your path to a Mobile app for existing projects. At this point, if your navigation items reside in custom navigation groups (other than "Default"), you will need to place them into the Default group.

In the future, it's likely that a different DevExpress Navigation Control (like the DevExpress Accordion) will be introduced to cover complex navigation hierarchies.

Simplified Testing - Local Simulator Built into your Mobile Project

Simulator (Index.html and player.html) - technically this is a web page that contains a client "player" script that queries the aforementioned backend data and UI metadata services and generates the actual HTML5/JS UI inside the web browser. This player script also gets redistributed to the actual mobile device when a native package is installed. The simulator is automatically opened in the web browser when you make a YourSolutionName.Mobile project as startup in Solution Explorer and start debugging (F5). Note: At present, this simulator downloads resources from Azure and thus requires at Internet connection. Going forward, this will not be required as all resources will be obtained from an assembly locally.

Secured OData Service with Basic Authentication

If you are not yet familiar with Basic Authentication and our its support in XAF v16.1, refer to this Wikipedia article: https://en.wikipedia.org/wiki/Basic_access_authentication#Client_side. Going forward, I will also use examples from this article to better explain the implemented feature.The mobile project created by the Solution Wizard consists of a DataService.svc file, representing the backend service used to serve requests, manage security and execute actions. Technically, it's a standard OData service (WCF Data Services 5.0) based on an XPO OData V3 provider.

Let me show how the security portion of this data service works:

A http://localhost:51562/DataService.svc/DevExpress_Persistent_BaseImpl_Task/$count service query produced the following results for different users, as expected:

    4 for Sam with an empty password (Authorization:Basic U2FtOg==);

    1 for Aladdin with the OpenSesame password (Authorization:Basic QWxhZGRpbjpPcGVuU2VzYW1l)

Based upon security permissions, only a single task is visible to Alladin while Sam sees all four tasks. User credentials are passed from the client to the service in request headers via the special Authorization field (see that base64-encoded thing in parentheses above). If you are curious as to how I modified request headers for these tests, I used the ModHeader plug-in from the Chrome Web Store:

The XAF mobile client queries the data service in a similar way, but does it behind the scene via AJAX requests. Below is a screenshot from the mobile simulator when a user Aladdin navigates to tasks: 

As you can see, the XAF Mobile UI works much like our Windows and Web interfaces with the same security settings:

The most important thing is that this secured XAF Data Service is not limited to XAF Mobile apps. You can leverage it from other non-XAF clients supporting Basic Authentication.

For instance, you can use our Data Explorer product for iOS with XAF's data service to generate a secured app:

Here I am just showing a couple of configuration steps along with the resulting app (which was generated from the XAF Data Service deployed in Azure -- http://maindemo.cloudapp.net/DataService.svc). You can find full configuration instructions for Data Explorer client apps in its getting started guide or in the How to use Data Explorer with the XAF secured OData Service supporting Basic Authentication KB article.

To obtain additional information on XAF Data Service and its usage from various clients, be certain to check out the following article: FAQ: New XAF HTML5/JavaScript mobile UI (CTP).

Windows Phone 8.1 Support

We have tuned native package settings so that they can be used on the Adobe PhoneGap Build service to generate an XAP file ready for Windows Phone 8.1 deployment. 

You can modify the config.xml file in the *.ZIP file we generate in order to specify the architecture of your device (anycpu, arm, x86 either x64): <preference name="windows-arch" value="anycpu" />
As for the future, we hope to simplify the current mechanism towards built-in Visual Studio integration so that you do not need to learn and use a separate service.

Updated Learning Materials and Demo for the Mobile platform

We have updated our Getting Started Tutorial and Frequently Asked Questions articles to reflect the latest changes in v16.1. If you don't have time to build your own XAF Mobile app but want to experience some of what's possible, feel free to try our Online Mobile Demo today.

Things we are still working on

We have mostly met the goals we set for ourselves in v16.1, but there are still many features we need to implement in order to consider XAF Mobile ready for its first beta. Specifically, we're focused on :  

• Improved stability, API;
• Look & feel and other UX related matters;
• Supporting frequently requested use-case scenarios;
• Improved online documentation;

It is likely that there will be more updates on this in the coming months. Follow our team blog for more information as it becomes available...

We would love to hear your feedback on XAF Mobile, so please contact us via the Support Center (preferred) or here in the Comments section.  

I wanted to draw your attention to a recent case study we published about DevPark's  https://www.fitness365.ru project. Roman Shelomanov and his team have created an XAF powered Web and Windows client with a common core and logic.

You can read the case study here: https://www.devexpress.com/Home/Case-Studies/fitness365/

Should you have an XAF project you'd like us to showcase on our site OR want to share suggestions on how you'd like us to improve your XAF development experience, please email me. Happy XAFIng

I'd like to preface this blog post with a recent quote from one of our loyal XAF users - Mario Blataric. He was an active beta tester in this release cycle. 

Here is what he wrote in an urgent DevExpress Support Center ticket: T460839 - Urgent, need to share 16.2 excitement !!  

We appreciate those of you willing to migrate your apps to our most recent builds. As I'm sure you can appreciate, feedback goes a long way to making our product more stable and easier to use. 

With that - let's take a quick look at the newest features shipping inside XAF v16.2.

New Dashboards Module (Windows and Web)

You can now leverage the flexibility of DevExpress Dashboard to create interactive decision support systems for Windows and the Web. We considered previously available custom solutions for the most popular dashboard scenarios (see this Support Center ticket) and determined that our best path forward was to deliver a universal Dashboards module. This built-in module should reduce the work and complexities associated with the integration of the DashboardViewer/DashboardDesigner and ASPxDashboard components into your next XAF-based WinForms and ASP.NET app.

If you're reading to give this new module a try, I suggest you start with our online documentation at Dashboards Module as well as XCRM and Feature Center demos.

Before I continue, I want to take a moment and emphasize that this new feature is a perfect example of what XAF is and how it's developed. Technically, XAF is a set of best practices and proven solutions - This set it finite as are our resources, but you are still "safe" and not "locked in". That is because you can always implement custom requirements, if a control or feature is currently unavailable - our team has done its best to ensure that the Framework is flexible and extensible. When we see high demand for a feature or we develop a better understanding of usage scenarios, new solutions typically get baked into the standard delivery.

Permissions for Navigation Items and Groups

With v16.2, you can grant or deny access for specific navigation items and groups in the Navigation Permissions tab of the PermissionPolicyRole Detail View:

Much like Dashboards, we have also reconsidered and integrated previously available custom solutions into our standard delivery. Take special note that this new feature is available only for permission policy and the PermissionPolicyRole class added in v16.1.

If you are still using SecuritySystemXXX classes, you might want to consider the following migration guidelines: 
How to use the Allow/Deny permissions policy (aka the PermissionPolicyUser and PermissionPolicyRole classes) in the existing project. 

If you're using Entity Framework and want to upgrade from v16.1 to v16.2, please review the following KB article:
How to: Add Navigation Permissions to an Entity Framework Application Created with XAF 16.1

Criteria Editor Enhancements (Web UI)

XAF's ASP.NET Criteria Property Editor now supports many of the features available in its WinForms counterpart, including:

• ability to display full object hierarchies, including members of reference and collection properties;
• use of built-in XAF editors for value types that don't have a native editor;
• ability to edit criteria as a string;
• display user-friendly criteria strings within the grid footer.

This feature is very helpful when configuring security permissions with criteria and a variety of other data analytics scenarios (e.g. with Pivot Chart - your end-users will love it!). Our wrappers around the DevExpress ASPxFilterControl also expose a number of options which you may want to tune based upon your business requirements (see the updated Concepts > Business Model Design > Data Types Supported by built-in Editors > Criteria Properties help article for more details).

Mobile Platform (CTP) Enhancements

We continue to focus energy on our new mobile UI, and in this release, we've incorporated the following enhancements:

• Improved look and feel, with new UI layouts optimized for desktop and tablet devices. What do you think of the new blue design, btw?
• Application Simulator no longer requires an internet connection. Previously, XAF users required to connect to our Azure-hosted web site for testing, which was not always convenient.
• 'Active' and 'Enabled' action states are now context-dependent, i.e. can be updated depending on whether the currently selected list or detail record matches some criteria.

We have also fixed a series of issues for improved stability. This mobile UI is still available as a CTP, because we have a number of things in our TODO list for the final release. These include: simplified localization, easier custom control integration and better support for extended modules like maps, reports, etc. Check out the links below to learn about what we ship in the box or how to add the same functionality to your next project:

Demo    FAQ    Tutorial    Video

I'll have more to share about XAF v16.2 in a subsequent post. In the meantime, I'd love to get your feedback on these new features.

Happy New Year!

Happy New Year Everyone!

Late last year, I described some of the new features we shipped as part of XAF v16.2. In this post, I'll discuss a few other enhancements we incorporated in v16.2.

Support for Multiple Browser Tabs

v16.2 includes support for a popular ASP.NET scenario - displaying multiple independent XAF views via browser tabs within the same web browser instance . If you've used XAF in the past, you'll know that this specific requirement was not easy to implement, as the XAF web site stored information about the current main window within the ASP.NET session between requests (learn more...). Technically, it still does, but with v16.2, each loaded web window has a unique identifier by which all requests are correctly routed on the server. 

With the new static WebApplication.EnableMultipleBrowserTabsSupport feature toggle, you can, for instance, include hyper links to two different XAF views in a customer email and when clicked, these links will open two separate browser tabs so that end-user can work with them independently.

Custom grouping of Application Model nodes in the Model Editor

This feature was inspired by customer feedback and to help explain it, let's consider a real world scenario. Assume that you have numerous custom Controllers placed in folders with the following naming convention:

In previous versions, XAF did not offer an easy way to navigate between these Controllers and Actions in the Model Editor due to the default grouping by the Action identifier. Essentially, users requesting this feature needed to provide custom grouping - similar to that found in Solution Explorer. With v16.2, you can use the new ModelEditorGroupingHelper API to customize default node grouping. Here is a sample screenshot from an actual end-user project:

Improved Web UI Theme Customization

Though this feature was derived from the DevExpress ASP.NET product library, I definitely want to make mention of it. Let me quote myself from my personal blog:

"There were a good number of requests to simplify the process of adjusting the New Web UI to match corporate colors. With v16.2, this process became much easier with the new options for changing the base color and font in code or configuration files of your app. Our XCRM.Web demo now contains a custom color/font scheme picker to demonstrate the use of these new release capabilities:

In addition, the XAF theme was better integrated with the ASPxThemeBuilder & ASPxThemeDeployer tools offered by our DevExpress ASP.NET team for creating and deploying custom themes. These actions appear to be a good start towards a "true" themes chooser requested by some customers or rather their end-users, who liked a vast number of predefined styles. The idea under consideration is  that we may support changing more theme parameters at runtime (e.g., the white background was reported as eye-fatiguing by some users), i.e., not only the main color and font."

Platform-Agnostic API for Displaying Dialogs

With v16.2, use of custom dialogs has been simplified for both WinForms and ASP.NET applications. The ShowViewStrategyBase.ShowViewInPopupWindow method displays the specified View in a popup dialog with OK and Cancel buttons:

Application.ShowViewStrategy.ShowViewInPopupWindow(Application.CreateDashboardView(Application.CreateObjectSpace(), "PaymentSuccessConfirmation", true));

You can also pass the okDelegate and cancelDelegate  parameters to this method and specify the code to be executed when the OK and Cancel buttons are clicked. Button captions can be customized using the okButtonCaption and cancelButtonCaption parameters.

In the following screenshot, you can see how a DashboardView configured in the Application Model can be used with this new method in an ASP.NET app:

The ShowViewInPopupWindow method provides a platform-agnostic way to display popup dialogs from your code. However, there are certain specifics in ASP.NET applications:

- The ShowViewInPopupWindow method can be used on XafCallbackManager callbacks initiated by the RaiseXafCallback script. It cannot be used on control callbacks (e.g., grid sorting).
- It is impossible to pause the current request to wait for user input.
- Main window is not refreshed when the Cancel button is clicked.

Improved Customization of Action Controls

The customization of UI controls used to visualize XAF Actions has been simplified. With v16.2, each Action exposes the CustomizeControl event that provides access to the underlying control including its context information. Related product documentation and examples like How to: Customize Action Controls and How to: Access Navigation Control were updated to reflect the new implementation. All of the possible scenarios are also demonstrated in the Action section of the Feature Center demo that is shipped with XAF. Below is a screenshot of Visual Studio demonstrating customization of a parametrized Action control in WinForms:

To learn more about the reasons behind this feature, be sure to check out my blog as well.

Instant Feedback UI Mode in WinForms GridListEditor

With this release, XAF List Views support our server-side data processing engine - Instant Feedback UI Mode. When used, your apps will remain responsive regardless of dataset size. To enable this feature, set the ListView's DataAccesMode property to InstantFeedback. Refer to the List View Data Access Modes  and How to: Access Objects Selected in the Current View help articles for more information on supported scenarios and usage specificities.

Faster App Startup

We've improved our Application Model cache (introduced in v16.1) and further reduced WinForms application startup times. To learn more, check out the XafApplication.EnableModelCache article for additional information. Please note that you can now enable parallel loading of business types and tune the model cache by setting the static DevExpress.ExpressApp.ModelCacheManager.UseMultithreadedLoading and DevExpress.ExpressApp.ModelCacheManager.SkipEmptyNodes properties to True before the XafApplication.Setup method is called in the YourSolutionName.Win/Program.xx file. Based upon tests with various large customer applications, startup time can be reduced up to 30% when implemented. In general, the more business classes and Controllers included in an app, the greater the impact from this enhancement.

As always, we welcome your comments and feedback. Tell us what you think of these new features.

With our new Maps module for XAF Mobile applications you can incorporate interactive maps and customize their providers and data source.You can start using this feature with the Visual Studio Toolbox and XAF designers or Solution Wizard - where you can add the new MapsMobileModule component:

Note: You must specify the MapsMobileModule.GoogleApiKey property in the MobileApplication.cs (MobileApplication.vb) file (refer to our Get API Key article to learn more).

This module includes both List and Property Editors designed to display, add and edit business objects such as addresses, companies or anything that implements the IMapsMarker interface on a map. The MobileMapsListEditor is the default List Editor used to display objects implementing this interface:

Once you configure the desired ListView using the Model Editor, it will convert the default data representation from a simple list into an interactive map displaying a list of markers:

You can also create new objects using the New Action or after a long tap on a map. In the DetailView, you can manually specify required coordinates or if you prefer to hide these properties, you can instead use the built-in Get Current Position command.

In DetailView, you can force the MobileMapsPropertyEditor to display IMapsMarker business objects as a map instead of standard drop down editors:

Minor Enhancements

In addition to this new module, we've also worked on a number of other minor features. For instance, with v17.1, non-persistent properties will be supported in XAF Mobile and XPO OData Service. If a non-persistent property includes business logic, our OData Service will automatically execute it and return the resulting value to the client. We have also developed a functional testing system based on our TestCafe product to improve the quality of mobile apps and I hope to briefly describe this feature in a future post. You can also explore and modify our pre-built mobile application at C:\Users\Public\Documents\DevExpress Demos 17.1\Components\eXpressApp Framework\MainDemo\CS\MainDemo.Mobile\ as we made it a part of the default installation. This should help you get you up to speed with of our mobile platform. We also made numerous improvements to the online documentation, though this process is not yet finalized and there are more changes to come.

In this post, I'd like to highlight a few of the more interesting enhancements we've made to XAF in this release cycle.

Platform Agnostic Notifications 

You can now display notifications to users (e.g. confirmation messages, warnings, errors) with ease by calling the new platform-independent ShowViewStrategyBase.ShowMessage method. Depending on method parameters and target platform, your message can be represented by Outlook-like alerts, Windows 10-like toast windows or flyout panels (all powered by DevExpress WinForms Controls and/or DevExtreme HTML 5 widgets). A typical example will look something like this: 

public class ProjectTaskController : ViewController {//… 
    MessageOptions options = new MessageOptions();
    options.Duration = 2000;
    options.Message = string.Format("{0} task(s) have been completed!", e.SelectedObjects.Count);
    options.Type = InformationType.Success;
    options.Web.Position = InformationPosition.Bottom;
    options.Win.Caption = "Success";
    options.Win.Type = WinMessageType.Toast;
    Application.ShowViewStrategy.ShowMessage(options);
}

Here are a couple of examples of the UX within Windows and XAF's Web UI:

You can play with this feature in our FeatureCenter. This feature has been successfully test-driven since its initial preview in v16.2.5. v17.1 includes enhancements based on customer requests and offers improved stability due to extended test coverage. Be sure to visit Concepts > UI Construction > Text Notifications to learn more about possible customizations and usage limits.

Optimized controller creation in ListPropertyEditor for detail collections

With this release, XAF powered applications with numerous Controllers associated with detail collections load faster. That is possible because we no longer instantiate non-activated View Controllers due to TargetViewType, TargetViewNesting, TargetObjectType or TargetViewId restrictions. This optimization is automatically enabled in newly generated XAF v17.1 apps. In apps created using older XAF versions, you can set the XafApplication > OptimizedControllersCreation property manually.

The second screenshot (B) illustrates where this improvement will be the most noticeable - a huge application with hundreds of Controllers:

High DPI improvements

In v17.1, desktop apps powered by XAF will offer a consistent appearance across a wide variety of high-DPI display settings. Your WinForms XAF applications will now be scaled correctly when setting the scaling factor (change text size, app and other item options) to a value greater than 100%. To enable the High DPI support, add the 'app.manifest' file to your project and enable the 'dpiAware' option. DPI-aware scaling is also enabled in XAF design-time tools.

Other important changes

Finally, I'd like to repost information from XAF's "Breaking Changes" section. Though not breaking changes, they are important things to consider for every single XAF user:

# BC4063 - More secure password generation algorithms for built-in security system classes are available in XAF v16.2 and v17.1
Refer to the FIPS-compliance changes to the DevExpress.Persistent.Base.PasswordCryptographer and DevExpress.ExpressApp.Utils.ImageLoader classes KB Article for additional information.

# BC4062 - The Frame.GetController<ControllerType> method may return null when the XafApplication.OptimizedControllersCreation property is set to true
XAF Solution Wizard now sets the XafApplication.OptimizedControllersCreation property to true for newly generated XAF projects. To avoid possible null reference exceptions in nested List Views, always check whether the Frame.GetController<ControllerType> method result is not null when the OptimizedControllersCreation property is true.

# BC4038 - WebLayoutManager - Initialization and usage of LayoutItemTemplateContainerBase descendants has been changed
Refer to the Web Layout Manager improvements and important changes in XAF v17.1 KB Article for additional information.

In addition to the Mobile UI features announced last month, we've been hard at work improving the quality and stability of mobile apps generated via XAF's mobile UI platform. Specifically, we have developed an internal functional testing system based upon TestCafe and successfully used it with our internal tests apps (MainDemo.Mobile among others). This online demo also uses our new DevExpress Logify service to track exceptions and improve overall product quality.

Frankly speaking, the main reasons we chose TestCafe was its simplicity and flexibility. TestCafe can be installed as nmp package with a simple command, and its API can emulate all necessary webpage actions. We're using our own wrappers for the Selector function to find different element types:

const activeViewSelector = Selector('.dx-active-view');
const textboxClassName = '.dx-texteditor-input';
//...
this.findTextBox = function (fieldName) {
    return activeViewSelector.find('div[data-options*="name: \'' + fieldName + '\'"]').find(textboxClassName);
}
//...

this.click = async function () {
     await this.waitElementToAppeared.apply(this, arguments);
     await this.testCafe.click.apply(this.testCafe, arguments);
     await this.wait();
     await checkForExceptions();
}

import { Selector, ClientFunction } from 'testcafe';
import { XafMobileTestHelper } from './lib/helper';
var helper = new XafMobileTestHelper();

fixture`MainDemo.Mobile.CRUD`
.beforeEach(async (t) => {
    helper.testCafe = t; await t.navigateTo('http://localhost/');
    await helper.switchToIframe("#simulatorFrame");
    await helper.typeText(helper.findTextBox("UserName"), "Sam", { replace: true });
    await helper.click(helper.findActionButton("Log On"));
});
test('Delete action(action with detail view)', async t => {
    await helper.click(helper.findNavigationMenuButton("menu"));
    await helper.click(helper.findNavigationItem('Task'));
    await helper.click(helper.findToolbarButton("New"));
    await helper.typeText(helper.findTextBox("Subject"), "Task To Delete");
    await helper.click(helper.findToolbarButton("Save"));
    await t.expect(helper.findListViewRecord("Task To Delete").exists).ok();
    await helper.click(helper.findListViewRecord("Task To Delete"));
    await helper.click(helper.findToolbarButton("Delete"));
    await helper.click(helper.findPopupActionButton("Yes"));
    await t .expect(helper.findListViewRecord("Task To Delete").exists).notOk();
});

If you are interested in learning more about our Mobile UI (CTP), check out eXpressApp Framework > Getting Started > XAF Mobile (CTP) Tutorial and feel free to contact us with any questions or suggestions via the Support Center (https://www.devexpress.com/ask).

With ourmost recent update (v17.1.4), the easiest way to integrate Logify within an XAF app is to use the LogifyAlertTraceListener API. You will find common and platform-dependent integration instructions for this recommended approach in the the following KB article https://www.devexpress.com/kb=T474018

Please note that we are using this exact approach for our online Web and Mobile demos (available at https://www.devexpress.com/Products/NET/Application_Framework/demos.xml). As you would expect, using Logify helps us improve product stability and product quality for both XAF's Mobile UI (CTP) platform and associated demo apps https://demos.devexpress.com/XAF/MainDemoMobile.

Logify itself is also widely used to deliver crash reports in other demos, runtime and design time tools for many DevExpress products and technologies:

Feel free to contact us if you're already using Logify (the product is currently an invitation only beta) and want to try this new approach. We will be more than happy to provide you with the assistance needed to get started.

We've created a KB article that describes how to scan barcodes in your XAF mobile application using the Cordova Barcode Scanner plugin: 

https://www.devexpress.com/kb=T530459

In this KB article, we'll show you how to implement an Action in a DetailView to save a scanned barcode to a current object property. Additionally, you will learn how to access the PhoneGap config file (regular XML file), add the plugin to your application and get access to the camera functionality with it.

Your feedback is needed!
This is not an official feature of our Mobile UI (CTP) and our API may change in future release cycles. We are publishing this article prior to the 17.2 release to collect early user feedback and improve overall functionality. We would appreciate your thoughts on this feature once you've had the opportunity to review it. Please report any issues, missing capabilities or suggestions in separate tickets in our Support Center. Thanks for your help in advance!

We've created a KB article that describes how to integrate push notifications into your XAF mobile application:

https://www.devexpress.com/go/XAF_Try_Mobile_PushNotifications_17.1_July.aspx

To help implement our solution, we used both the phonegap-plugin-push and Azure Notification Hub tool. We've opted for the latter because it is an easy-to-use, multi-platform, scaled-out push engine that allows you to make a single cross-platform API call to send targeted and personalized push notifications to any mobile platform (Android/iOS/Windows) from any cloud or on-premises backend. Of course, you can use the native APIs offered by Google/Apple/Microsoft or any other third-party notification services instead.

Your feedback is needed!
This is not an official feature of our Mobile UI (CTP) and our API may change in future release cycles. We are publishing this article prior to the 17.2 release to collect early user feedback and improve overall functionality. We would appreciate your thoughts on this feature once you've had the opportunity to review it. Please report any issues, missing capabilities or suggestions in separate tickets in our Support Center. Thanks for your help in advance!

Another development sprint is over, and I want to publish some of our results for those interested in creating mobile apps with XAF.

We have created an example that demonstrates the use of a mobile device positioning system via Cordova's Background Geolocation plugin and Cordova Device plugin

    https://www.devexpress.com/go/XAF_Try_Mobile_BackgroundGeoLocation_v17.1_August.aspx

These features are helpful when you wish to automatically track the whereabouts of an XAF mobile app user and display the user's route on a map (e.g., in a separate administrative XAF Web application):

You can test this example live with XAF v17.1.5, which we released earlier this week.

We are completing our work on XAF's PhoneGap plugins support and as a result, we've updated our online documentation to describe basic concepts and include information about the APIs used in recent examples (one, two). The updated topics include, but are not limited to the following:

DevExpress.ExpressApp.Mobile > MobileApplication
    CustomizePhoneGapConfig
    RegisterClientScriptBeforeSendRequest
    RegisterClientScriptOnApplicationStart

DevExpress.ExpressApp.Mobile > MobileWindow
    RegisterClientScriptOnDispose
    RegisterClientScriptOnHide
    RegisterClientScriptOnLoad
    RegisterClientScriptOnShow

DevExpress.ExpressApp.Actions > ActionBaseExtensions
    GetProcessActionOnServerScript
    RegisterClientScriptOnExecute

Concepts > Application Life Cycle > Mobile Application Life Cycle

The next XAF version (17.1.6) will also provide a simpler way to register plugins through the new MobileApplication.AdditionalPhoneGapPlugins property instead of the general-purpose CustomizePhoneGapConfig event, but we'll focus on this and other improvements next time.

Happy XAFing and have nice weekend!

We recently published a case study regarding two ISDK web projects built with the eXpressApp Framework: https://www.devexpress.com/Home/Case-Studies/ISDK/ 

Please note that they opted to generate their web UI using our Classic Web UI option (learn more about the other option).

I want to thank Dmitry Kovrizhko, General Manager at ISDK LTD, for finding the time in his busy schedule to share his project with us. I first met Dmitry in person several years ago at a conference. We talked a length about his experiences with XAF and have obviously engaged one another via the DevExpress Support Center, Facebook and email since. 

If you are considering XAF for your development needs, you may want to note the following comments from Dmitry:

"With these tools, they didn't need to think about basic development and other things that take up time, such as database setup, low-level data layers, low-level UI drawings and so on. They basically used out-of-the box capabilities so they could focus on the core business needs."

"About 80% of the project's objectives and features were met using the standard XAF/XPO methodology. Using our framework, ISDK could quickly and easily add modules for Appearances, Audit, Reporting, etc. The other 20% was met using common .NET and JavaScript."

The latter point is important and something we try to emphasize with all of our customers - XAF does not pretend to be a single-point solution for everything. For over a decade, we've been focused on a true *framework,* with a solid and extendable foundation: a set of ready-to-use general best patterns and practices designed around DevExpress visual components. You can obviously use XAF "as is" or customize it to build various line-of-business applications tailored to your specific customer requirements. For more information on the XAF approach to software development, please visit the following page: eXpressApp Framework > Fundamentals > XAF Overview

Should you have an XAF project you'd like to showcase on our site OR want to share your opinions with us, please email me. Happy XAFing

We've created a KB article that describes how you can extend your XAF mobile application so that can change the application's Data Service dynamically after logon:

https://www.devexpress.com/go/XAF_Try_Mobile_DataServiceUrlSelection_v17.1_August.aspx

This information will be helpful to those who need to supply the same application to different customers (companies). Company data should be stored separately in different databases. The database (or, to be more precise, the Data Service connected to it) should be selected in one of the following ways: 
- The user enters his or her credentials, and the application's Data Service is changed dynamically based on the logged in user.
- The user specifies his or her Data Service manually in the logon screen.

It's possible that we'll extend this feature so that you'll not need to maintain separate data services for each company (a different database will be chosen dynamically), but first, we would love to learn whether the current implementation covers your specific use-case scenarios.

Your feedback is needed!
This is not an official feature of our Mobile UI (CTP) and our API may change in future release cycles. We are publishing this article prior to the 17.2 release to collect early user feedback and improve overall functionality. We would appreciate your thoughts on this feature once you've had the opportunity to review it. Please report any issues, missing capabilities or suggestions in separate tickets in our Support Center. Thanks for your help in advance!

We've added a mobile property editor to the following Support Center example: How to show a hyper link (URL, email, etc.) for a business class property. The example demonstrates how to create custom data representations (hyperlinks) for your text properties. To view implementation details, open the example's page and show MobileHyperLinkStringPropertyEditor.cs/vb in the code file selector at the bottom.

If you create and deploy a mobile XAF app using this custom editor, it will look like the following:

We have also published numerous online documentation updates for related mobile and core XAF APIs demonstrated earlier. For instance, the following topics have been updated to describe mobile versions of property editors for various data types:

- String Properties   - Numeric Properties   - Date and Time Properties   - Boolean Properties   - Collection Properties   - Reference (Foreign Key, Complex Type) Properties   - File Attachment Properties   - Enumeration Properties   - Type Properties

In addition to screenshots and text descriptions, the most interesting information for developers would be links to corresponding DevExtreme widgets on which these mobile property editors are based on. This documentation is not yet finished, and we hope to provide more information on extending the standard XAF mobile UI with custom-tailored editors in the coming weeks.

Additionally, we have improved documentation that helps explain how you can register XAF property editors:

• EditorAliasAttribute Class
• EditorAliases Structure
• ModuleBase Class
• ListEditorAttribute Class
• PropertyEditorAttribute Class

We have reworked XAF’s permission processing algorithm. It is now faster and ships with improved ways to extend existing permission functionality (thus simplifying code maintenance).

Find more technical details at https://www.devexpress.com/go/XAF_Try_Security_Optimizations_v17.2_September.aspx

If you are an active v17.1 subscriber and want to test this new permission processing engine with your real world applications on a virtual machine (or another suitable test environment) prior to the official release, please leave a comment to this KB article or create a separate private ticket, so that we can verify your account and provide you with the v17.2 preview installation privately.

Please report any issues and suggestions in the Support Center once you've had an opportunity to try this new feature in your upgraded v17.2 project. Thanks for your help in advance!

New WinForms Light Style

The new Light Style form templates (LightStyleMainRibbonForm and LightStyleMainForm) with both Ribbon and Standard menus are now available for WinForms apps. This new style layout is "cleaner," as it eliminates excessive borders. The images help demonstrate the difference between our previous (left) and new layout (right):

Use the WinApplication.UseLightStyle property to enable this feature in existing apps. If you have custom Nested Frame, Lookup Control, Lookup Form, or Main Form templates,
you need to update them to make it possible to use Light Style: How to enable Light Style in custom WinForms Templates after upgrading to v17.2+. All newly created apps will use this new style by default.

We are committed to improving the WinForms UI further and you will likely see more news in this regard in the future ( specifically regarding use of SVG images instead of our current images set). 

Display Reports & Dashboards in a Maximized State within a Separate Browser Tab

ASP.NET users can now open dashboards and reports within a separate web browser tab (via UI or by direct URL) using all the available space on the page (without XAF navigation elements and toolbars).

Working with dashboards and reports in a separate web browser tab is supported in the following scenarios: 

1. A user holds the Ctrl key, clicks a report or dashboard definition record in a ListView and the corresponding viewer is opened in a new tab.

2. A user opens a dashboard or report designer in a separate tab using specialized menu commands (the DashboardsAspNetModule > DesignerDisplayMode 
and ReportsAspNetModuleV2 > ShowReportDesignerActionTarget options can be set to 'NewTab').

3. A user opens the current dashboard preview in a new browser tab using the new ShowDashboardInSeparateTab menu command.

NOTE: These scenarios only work for applications with WebApplication > EnableMultipleBrowserTabsSupport set to True.

This short video below describes how you can enable all these options:

We'd love to get your feedback on the following two features shipping with XAF v17.2: localization support and custom mobile modules.

Localization Mobile Module

Our new Localization Mobile Module allows you to instantly translate your entire app UI – either on demand, as described in our how-to article, or automatically, based on the target browser’s settings. The module already includes the necessary resources for German, Japanese and Russian languages. To extend the list, simply supply your custom dictionary.

Custom Modules

Support for custom modules allows you to extend your XAF mobile apps by embedding third-party JavaScript controls. To see how you can integrate business-specific functionality with relative ease, review our new KB article: How to use a Signature Pad in XAF Mobile, or our new help topic: How to: Use a DevExtreme Chart in a Mobile Application.

Have you already updated to XAF 17.2? What do you think of our new XAF Mobile features? We'd love to hear from you in the comments below.

And keep an eye out for our upcoming builds with early v18.1 feature previews, including the new Report Viewer. We'll let you know when it's available for testing.

Your feedback counts!

As part of our ongoing commitment to support the needs of our XAF customers, the upcoming v18.1 release will ship with several major features. Many of them are inspired directly by customer feedback!

If you are an active v17.2 subscriber and you’d like to test these new features prior to the official release, please create a private ticket in the Support Center. We will verify your account and provide you with the v18.1 preview installation privately.

By providing early build access, we hope to find out whether our new features and solutions address your requirements and issues. Your testing efforts and your feedback help us deliver the best possible final implementation. My colleague Mehul has recently described other benefits of this cooperation in his great post here.

In advance, thank you very much for your help!

New Rich Text Editor Module for WinForms

As you may already know, the DevExpress WinForms Rich Text Editor is part of a powerful word-processing library, allowing you to create, load, modify, print, save and convert rich text documents. In 2018, we will introduce a new XAF property editor based on this control. It will be available for byte array or text properties and will support mail merge.

Earlier, we have already collected community feedback on our initial vision of this new module, to make sure we don’t miss any important use-case scenarios. This time we want you to test our first implementation in your real projects and clarify some new functionality.

To learn more about the new Rich Text Editor module capabilities and for getting-started instructions to empower your WinForms projects with it, please read this knowledge base article.

SVG Icons Support for WinForms

One of our primary objectives in 2018 is to improve the appearance of XAF desktop apps on high resolution displays. To achieve this, we will work to replace all default XAF PNG icons with their SVG equivalents (by the end of 2018).

First however, we need to ensure that all XAF visual elements support SVG images themselves: menus and navigation elements, the DetailView layout groups and tabs, built-in property editors, form templates, etc.

To check our progress in this regard and to help future development by answering questions from our team, please read this knowledge base article.

New Lookup Property Editor for ASP.NET WebForms

We will ship a new Web property editor for reference properties — one that is based on the DevExpress ASPxGridLookup. As you may already know, the existing ASPxLookupPropertyEditor relies on the ASPxComboBox and the ASPxPopupControl, and has not evolved much in recent years.

Our main reason to replace the ASPxLookupPropertyEditor is that the new ASPxGridLookup ASP.NET component brings lots of new useful features, including multiple columns, better server mode support, incremental search, filtering, sorting, and others.

To learn more about the new ASPxGridLookupPropertyEditor capabilities and for getting-started instructions to enable it for Web projects, please read this knowledge base article.

Security Diagnostic Tool

We created this new tool to help XAF users understand why access to a certain object and its members is allowed or denied by security permissions. This is also helpful to us, reducing time spent on diagnosing customer issues related to security permissions.

The tool is already available for early testing in v17.2.6+, and you can enable it using the familiar EnableDiagnosticActions option.

To learn more about saving development and maintenance time with this tool, please read this knowledge base article.

I have some interesting news from a longtime XAF customer (and DevExpress MVP) Dave Hesketh. You may know Dave from his Support Center contributions and his XAF training and consulting services.

Dave has just introduced Llamachant Framework Modules at http://www.llamachant.com/single-documents/llamachant-framework-modules/.

Here is a quote from his site along with feature descriptions:

"We have worked with clients from all around the world and we discovered that many of them wanted to implement similar features in their solutions. We collected a few of the most common requests and created a reusable module that we wanted to share with everyone!"

Be sure to visit http://www.llamachant.com/single-documents/llamachant-framework-modules/ for more information.

Feedback and other XAF extensions

Even though certain features from this list can be found in the DevExpress knowledge base, it is valuable to have them all in a form of a reusable XAF module. I hope that XAF community members will enjoy this functionality or at least learn from its implementation. Hopefully, Llamachant will evolve and support these extensions over the long haul...on GitHub or another suitable locations. 

I should also mention that additional XAF extensions can be obtained from https://www.devexpress.com/Products/NET/Application_Framework/xaf-community.xml. This includes the eXpand Framework - the first open source toolkit for XAF and the Xafari Framework - both free and paid modules from Galaktika Soft.

Did you find this blog post and Dave's module helpful? Or are you developing the next eXpand on GitHub? Please let us know!

Our XAF Mobile Report Viewer is now available for testing! It ships with the v17.2.7 update as a preview you can enable using a feature flag. We expect to release the Report Viewer in v18.2.

Previously, end users could view and download reports in WinForms and ASP.NET applications, but only download reports in Mobile applications. The new Mobile Report Viewer allows end users to view and download reports - just like in their desktop and web applications. The Report Viewer is based on the HTML5 Document Viewer and uses its Mobile Mode.

Ready to try the new Report Viewer? Read our new KB article to learn how to use the new feature: XAF Mobile Report Viewer - Preview in v17.2.7+. Remember to backup your projects before testing.

We Need Your Feedback
Try the Report Viewer and tell us what you think. How did you like it? How can we improve it? We would like to hear from you and we appreciate your help improving XAF Mobile.