Building Mobile Experiences

In this edition of Low-code in 30, Mendix evangelist Simon Black demonstrates building mobile experiences in the Mendix platform.


  • Transcript

    [00:00:11.540]
    hello and welcome to

    [00:00:14.230]
    30 my name is simon black and i’m a

    [00:00:16.750]
    technology evangelist here of mendax and

    [00:00:18.939]
    today’s webinar we’re going to cover

    [00:00:20.859]
    building mobile experiences so these

    [00:00:26.619]
    webinars run on a monthly basis and in

    [00:00:29.079]
    each monthly webinar we try to cover off

    [00:00:31.480]
    a particular topic around a local aid

    [00:00:33.640]
    development it may we looked at how you

    [00:00:36.370]
    can collaborative visually develop

    [00:00:38.320]
    applications using things such as the

    [00:00:40.780]
    web modeler to rapidly build

    [00:00:42.420]
    applications without code in June we

    [00:00:46.089]
    took a look at how we can build

    [00:00:47.379]
    beautiful multi-channel applications and

    [00:00:49.690]
    leveraging things like the Atlas UI

    [00:00:51.940]
    building blocks and also the mendax web

    [00:00:55.000]
    modeler to rapidly build those

    [00:00:56.770]
    applications in today’s webinar we’ll

    [00:01:00.100]
    focus on building mobile experiences so

    [00:01:02.800]
    we take a look at how we can build both

    [00:01:04.360]
    online and offline experiences but also

    [00:01:07.149]
    extend that application how to other

    [00:01:09.250]
    devices such as wearables and Chapel our

    [00:01:11.770]
    interfaces in August we’ll take a look

    [00:01:15.640]
    at how you can build smart applications

    [00:01:17.560]
    a smart application is an app that

    [00:01:19.720]
    leverages IOT services blockchain

    [00:01:22.630]
    services and also cognitive services to

    [00:01:25.750]
    be able to create a unique experience

    [00:01:27.670]
    which is leveraging existing data and

    [00:01:30.640]
    building new types of applications and

    [00:01:34.800]
    finally in September we’ll look at how

    [00:01:37.149]
    you can take your mendax applications

    [00:01:38.800]
    and deploy those to any architecture you

    [00:01:41.140]
    need whether it be on any cloud of your

    [00:01:43.660]
    choice or on-premise environment and the

    [00:01:48.640]
    structure of these webinars is that

    [00:01:49.929]
    we’ll in five minutes cover at

    [00:01:51.610]
    presentation in 25 minutes we’ll look at

    [00:01:54.340]
    a demo of the mendax platform and

    [00:01:56.410]
    finally we’ll have a live Q&A we can ask

    [00:01:59.470]
    us questions about the technology so to

    [00:02:05.050]
    give you some insight as to what mendax

    [00:02:07.000]
    is about mendax is a company that is

    [00:02:10.209]
    born to help enterprises win with apps

    [00:02:12.640]
    and mendax is the fastest and easiest

    [00:02:14.770]
    local platform to enable you to create

    [00:02:17.500]
    and continuously improve mobile and web

    [00:02:20.140]
    applications and we do that by using

    [00:02:23.109]
    visual models

    [00:02:24.250]
    so rather than coding an application we

    [00:02:27.010]
    allow you to

    [00:02:27.959]
    the the pages the data and also the

    [00:02:31.739]
    logic using visual models and deploy

    [00:02:34.170]
    those applications to wherever you need

    [00:02:36.769]
    the whole platform is designed to bring

    [00:02:39.390]
    both business and IT together allowing

    [00:02:41.939]
    them to collaborate throughout the whole

    [00:02:43.650]
    application lifecycle everything from

    [00:02:46.590]
    gathering requirements developing your

    [00:02:48.450]
    application and finally deploying your

    [00:02:50.489]
    application is available within the

    [00:02:52.560]
    mendax platform allowing you to create

    [00:02:54.959]
    applications ten times faster and using

    [00:02:57.930]
    70% best resources so if we take a look

    [00:03:05.129]
    at user interfaces and also mobile

    [00:03:07.530]
    devices there’s an ever-expanding amount

    [00:03:10.829]
    of devices out there we’re starting to

    [00:03:13.109]
    seeing the emergence of chatbot

    [00:03:14.969]
    interfaces but also wearable devices

    [00:03:17.099]
    that our customers are expecting us to

    [00:03:19.620]
    provide our applications out to so we

    [00:03:23.340]
    have new ways of interacting with these

    [00:03:25.349]
    devices so rather than whether they be

    [00:03:27.989]
    through speech whether it be for a chat

    [00:03:30.329]
    bot we need to be able to cater for

    [00:03:32.129]
    these different types of devices and

    [00:03:36.569]
    this is becoming a challenge and

    [00:03:38.340]
    Gardiner sees that 90% of all large

    [00:03:40.979]
    organizations are not leveraging their

    [00:03:44.220]
    mobile strategy and there’s one good

    [00:03:46.109]
    reason and that’s because they’re

    [00:03:47.430]
    siloing their investment in mobile

    [00:03:49.620]
    development they’re taking each of these

    [00:03:52.199]
    particular mobile applications or mobile

    [00:03:54.599]
    devices they need to cater for

    [00:03:56.180]
    developing in different technology and

    [00:03:58.949]
    not having a single strategy to cover up

    [00:04:01.500]
    each of those devices so to help with

    [00:04:06.959]
    this loko platforms bridge the gap and

    [00:04:09.180]
    allow you to build those applications

    [00:04:10.729]
    for multiple different types of mobile

    [00:04:13.079]
    devices and allows you to build your

    [00:04:15.750]
    applications for all of those devices

    [00:04:17.519]
    but build them in one core platform so

    [00:04:21.329]
    rather than building them in different

    [00:04:22.440]
    technologies different languages such as

    [00:04:24.599]
    your iOS or Android development you can

    [00:04:27.330]
    build in one application platform and

    [00:04:29.550]
    deploy those out to multiple devices a

    [00:04:34.130]
    loko platform also needs to be able to

    [00:04:37.050]
    be offline and online you need to be

    [00:04:40.260]
    able to have the same experience

    [00:04:41.810]
    you’re users across your application

    [00:04:43.850]
    whether they have signal or whether they

    [00:04:45.919]
    don’t have signal so they need to be

    [00:04:48.080]
    able to have that experience going

    [00:04:49.730]
    forward and be able to build those

    [00:04:51.860]
    applications easier than developing them

    [00:04:54.470]
    in traditional coding languages any loco

    [00:04:59.570]
    platform needs to be able to utilize the

    [00:05:01.340]
    native device features so customers

    [00:05:03.860]
    expect the high level interaction with

    [00:05:06.770]
    their mobile devices they expect swipe

    [00:05:09.320]
    gestures they expect camera integration

    [00:05:11.840]
    and so on out-of-the-box with any

    [00:05:14.030]
    application built with a platform you

    [00:05:19.090]
    also need to be able to deploy these

    [00:05:21.650]
    applications much quicker so once you

    [00:05:24.050]
    built your application you don’t want to

    [00:05:25.580]
    be waiting for deployment of your

    [00:05:27.830]
    architecture and building your

    [00:05:29.630]
    application by your ops team you need to

    [00:05:31.910]
    be able to one-click deploy your

    [00:05:33.200]
    application out to any cloud or

    [00:05:35.060]
    on-premise environment but also that

    [00:05:37.280]
    application needs to be rolled out to

    [00:05:38.930]
    the customers devices so with a local

    [00:05:41.570]
    platform you’re able to do that you’re

    [00:05:43.400]
    able to do over there updates so that

    [00:05:46.100]
    your application can be deployed

    [00:05:47.419]
    straight to the customers app and phone

    [00:05:49.760]
    as soon as that deployment is done and

    [00:05:54.400]
    finally any local platform needs to be

    [00:05:57.080]
    able to be extendable you need to be

    [00:05:59.150]
    able to create your services correct

    [00:06:01.340]
    rest and slope services to leverage that

    [00:06:03.320]
    logic and expose it out to other devices

    [00:06:06.050]
    whether they be on chat bot interfaces

    [00:06:08.810]
    where if they be on wearable devices you

    [00:06:11.150]
    need to be able to expose that data as a

    [00:06:13.310]
    set of services so in our demo today

    [00:06:18.830]
    what I’m going to do is I’m going to

    [00:06:20.120]
    show you an example application I’m then

    [00:06:22.729]
    going to show you how to make a change

    [00:06:24.289]
    to that application and finally we’ll

    [00:06:26.510]
    look at how we can extend the app

    [00:06:28.720]
    utilizing a rest service so we can

    [00:06:31.400]
    expose it out to other devices we may

    [00:06:33.440]
    want to connect up so the application

    [00:06:40.490]
    that we’re going to look at today is

    [00:06:41.870]
    available on the mendax app gallery and

    [00:06:44.180]
    the app gallery is built by the

    [00:06:45.380]
    evangelist team and there we build a

    [00:06:47.990]
    number of applications that are built to

    [00:06:49.940]
    inspire these applications might utilize

    [00:06:53.450]
    a number of innovative technology

    [00:06:55.650]
    such as blockchain and and also higher

    [00:06:59.820]
    tea services to be able to showcase what

    [00:07:02.400]
    his are to the possible with mendax so

    [00:07:06.240]
    we’ve built a number of applications

    [00:07:07.110]
    across different industries whether it

    [00:07:09.240]
    be from healthcare whether it be

    [00:07:11.130]
    financial services insurance and so on

    [00:07:13.020]
    but the application we want to focus in

    [00:07:15.270]
    on today is the homecare application

    [00:07:17.600]
    this particular application allows

    [00:07:19.949]
    remote field workers to be able to go

    [00:07:22.110]
    out to a particular customer and be able

    [00:07:24.750]
    to ask and answer a number of questions

    [00:07:26.820]
    on-site so they need to be able to do

    [00:07:29.580]
    this both online and offline they need

    [00:07:31.710]
    to be able to get navigation for

    [00:07:33.270]
    instance when they’re online and when

    [00:07:35.190]
    they’re offline in remote regions they

    [00:07:36.780]
    need to be able to answer questions

    [00:07:38.310]
    about the particular appointment they’re

    [00:07:40.500]
    out so let’s take a look at that

    [00:07:45.240]
    application and show you what the

    [00:07:46.800]
    functionality looks like so I’m just

    [00:07:48.960]
    going to open up my mobile device here

    [00:07:50.699]
    and this is running on my Android device

    [00:07:52.590]
    here I can see with this application a

    [00:07:55.860]
    menu bar on the top here and I can

    [00:07:58.169]
    scroll for a number of dates with this I

    [00:08:01.080]
    can select a particular date and filter

    [00:08:03.060]
    the list of appointments I can also use

    [00:08:05.160]
    this search option up here to search for

    [00:08:07.560]
    particular appointments within my

    [00:08:09.120]
    application the top here we have our

    [00:08:14.130]
    current appointment and at the bottom

    [00:08:16.260]
    here we have a list of upcoming

    [00:08:17.699]
    appointments if I slide on these

    [00:08:20.159]
    particular upcoming appointments I can

    [00:08:21.840]
    see options to open up a map text or

    [00:08:25.590]
    call all of in the operations of the app

    [00:08:28.500]
    so if I select the map option it can ask

    [00:08:31.440]
    me where once you actually let go I can

    [00:08:34.080]
    select the text option to open up a

    [00:08:36.330]
    message dialog so I can send it an SMS

    [00:08:38.550]
    message to this particular user so say

    [00:08:42.120]
    for instance I’m on my way I might want

    [00:08:43.709]
    to send them a message to them I can use

    [00:08:46.350]
    these buttons in these native

    [00:08:47.880]
    interactions they’re available in the

    [00:08:49.890]
    mendez platform to give that interaction

    [00:08:53.779]
    if I click the View button here I can go

    [00:08:56.580]
    down into the particular point then and

    [00:08:58.620]
    with this particular appointment I could

    [00:09:00.240]
    see information about where the

    [00:09:02.130]
    appointment is I can also see some tasks

    [00:09:04.470]
    information as well and I can drill down

    [00:09:06.810]
    on that task information to get some

    [00:09:08.579]
    more deep

    [00:09:09.030]
    tells within each task we have a number

    [00:09:11.850]
    of questions which are dynamically

    [00:09:13.860]
    configured within our application

    [00:09:15.560]
    allowing us to answer certain

    [00:09:17.880]
    information using different types of

    [00:09:20.250]
    input fields whether it be a slider

    [00:09:22.980]
    whether it be input fields for instance

    [00:09:25.380]
    or radio buttons we can add those into

    [00:09:28.740]
    our application and we can make those

    [00:09:30.210]
    available as questions in the app so

    [00:09:35.490]
    what we want to do is I want to show you

    [00:09:36.720]
    how we can make it change this

    [00:09:38.010]
    application how we can then deploy this

    [00:09:40.650]
    application locally and show you their

    [00:09:42.420]
    hot reloading and then finally deploy

    [00:09:44.670]
    this application out to a mobile device

    [00:09:48.260]
    so the first thing we want to do in this

    [00:09:50.550]
    application we want to add a new feature

    [00:09:52.290]
    we want to add the ability for each of

    [00:09:54.990]
    these questions to have the option to

    [00:09:56.970]
    upload a set of photos be able to see

    [00:10:00.120]
    those photos and finally be able to

    [00:10:02.550]
    control the notes field here so that we

    [00:10:05.190]
    can actually show or hide that notes

    [00:10:07.560]
    field based on a particular option so

    [00:10:14.670]
    let’s go ahead and look at how we can

    [00:10:16.500]
    make those changes to this particular

    [00:10:18.030]
    application so if I crater close down my

    [00:10:22.080]
    mobile preview here and I can open up

    [00:10:24.900]
    the mendax business modeler this is an

    [00:10:28.140]
    install on my local machine and it

    [00:10:30.210]
    allows us to build out our application

    [00:10:32.040]
    using visual models now we have two

    [00:10:34.410]
    versions of our modeling environment we

    [00:10:36.060]
    have a desktop version which allows more

    [00:10:39.180]
    business IT focused people to develop a

    [00:10:41.850]
    plaque out applications integrate into

    [00:10:45.030]
    certain services but we also have a web

    [00:10:47.940]
    version as well and the web version is

    [00:10:50.070]
    of what-you-see-is-what-you-get online

    [00:10:51.960]
    editor in the web allowing you to build

    [00:10:54.480]
    out your application without having to

    [00:10:56.190]
    have any ID knowledge so in the business

    [00:11:02.010]
    modeler here on the desktop we can view

    [00:11:04.020]
    our application we can see the page that

    [00:11:05.880]
    were on earlier so we have the ability

    [00:11:07.650]
    to switch between a view mode and the

    [00:11:09.660]
    edit mode to be able to see what the

    [00:11:11.790]
    page is going to look like when we’re

    [00:11:13.140]
    developing it so the first thing we want

    [00:11:16.410]
    to do is when we’re making this change

    [00:11:17.670]
    is we want to add some new data for this

    [00:11:20.700]
    photo and

    [00:11:21.930]
    wanna be able to store that in our

    [00:11:23.910]
    application so the first thing we need

    [00:11:27.480]
    to do is we need to add some data and we

    [00:11:29.460]
    need to create a new data table to be

    [00:11:31.320]
    able to store that information so we do

    [00:11:34.050]
    that using the visual domain model and

    [00:11:36.540]
    this is where we can build out our

    [00:11:38.040]
    application using drag-and-drop

    [00:11:40.410]
    interface to build out our entities or

    [00:11:42.779]
    tables and also our associations between

    [00:11:45.300]
    them so we have a question here and for

    [00:11:48.240]
    each question we want to be able to

    [00:11:49.560]
    upload a set of photos so first of all

    [00:11:52.500]
    I’m going to add on a new activity I’m

    [00:11:54.209]
    going to call this photo and I’m also

    [00:11:58.529]
    going to inherit the system image the

    [00:12:02.010]
    system image allows us to automatically

    [00:12:04.080]
    upload and store photos within our

    [00:12:06.240]
    application we also have one for file

    [00:12:08.459]
    document as well and it’s a quick way to

    [00:12:10.500]
    be able to inherit of a functionality

    [00:12:12.600]
    within your application now for this

    [00:12:16.050]
    particular application I want to have

    [00:12:17.399]
    multiple photos for a question so all I

    [00:12:20.010]
    need to do is I need to drag from the

    [00:12:21.750]
    entity on the photo to our question

    [00:12:24.120]
    which will automatically create a so

    [00:12:25.980]
    Association so that we can have multiple

    [00:12:28.260]
    photos and against one particular

    [00:12:31.290]
    question the next thing we need to do is

    [00:12:35.070]
    now that we’ve built our particular data

    [00:12:37.080]
    we need to build out the user interface

    [00:12:39.330]
    for our application and the way we do

    [00:12:41.430]
    that is we use the visual pace builder

    [00:12:43.500]
    to build out that application so when

    [00:12:48.690]
    we’re building out our application we

    [00:12:50.400]
    can build for different device profiles

    [00:12:52.620]
    so within the mimic platform we have the

    [00:12:54.839]
    ability to have additional profiles and

    [00:12:57.779]
    additional pages per different device so

    [00:13:00.990]
    if we add an app navigation profile home

    [00:13:02.820]
    here we can see we have the ability to

    [00:13:04.680]
    create online and offline pages were

    [00:13:07.770]
    able to create browser and tablet and

    [00:13:09.959]
    mobile pages so that you can pacifically

    [00:13:12.420]
    design your application the way you need

    [00:13:14.820]
    for those individual device types so for

    [00:13:18.930]
    our example we have a hybrid phone app

    [00:13:21.950]
    offline application here and we can

    [00:13:25.110]
    click this show option to take us to the

    [00:13:26.880]
    page for this particular first

    [00:13:28.740]
    application now the page that we want to

    [00:13:32.040]
    change is we want to change the view

    [00:13:33.750]
    topic information

    [00:13:34.899]
    and I’ve just opened this up in the edit

    [00:13:36.970]
    mode here I can switch between edit and

    [00:13:39.249]
    view mode to see what that application

    [00:13:40.600]
    is going to look like so here we go we

    [00:13:44.170]
    have our notes field and we also have

    [00:13:46.329]
    the questions that we we can answer so

    [00:13:49.839]
    the first thing we want to do is we want

    [00:13:51.009]
    to drag on a new component and this

    [00:13:53.379]
    component is going to be a building

    [00:13:55.209]
    block and the building blocks are

    [00:13:56.920]
    available and we covered these in a

    [00:13:58.749]
    previous session they label you to write

    [00:14:01.269]
    very rapidly build out the user

    [00:14:02.949]
    interface and look of feel for your

    [00:14:04.629]
    application

    [00:14:05.410]
    so when we simply add on a navigation

    [00:14:08.019]
    block here and as you can see here we

    [00:14:10.389]
    have the camera option we have a photo

    [00:14:13.660]
    gallery and also an option for our notes

    [00:14:16.329]
    field but at the moment these particular

    [00:14:18.429]
    buttons part can figured up to do

    [00:14:20.139]
    anything so we need to build that

    [00:14:21.910]
    knowledge economy to build that

    [00:14:23.290]
    interface into the app so the first

    [00:14:26.800]
    thing we want to do is for this

    [00:14:27.790]
    particular button we have the ability to

    [00:14:30.100]
    add a new photo so we select an entity

    [00:14:33.730]
    from my domain model on what I’ve just

    [00:14:35.740]
    created earlier so I’ve got my photo

    [00:14:37.869]
    here I could select photo little labels

    [00:14:40.779]
    me to then create live photo for my

    [00:14:42.639]
    application but what I want to do as

    [00:14:45.009]
    well for this particular entities I want

    [00:14:46.990]
    to be able to set an association so by

    [00:14:49.449]
    selecting because I’m in a question it

    [00:14:52.350]
    automatically options to set the

    [00:14:54.970]
    association between my question and my

    [00:14:57.249]
    photo the next thing I want to do is I

    [00:15:01.779]
    want to be able to show a page I want to

    [00:15:03.879]
    be able to give the user the ability to

    [00:15:05.519]
    take that photo be able to store it and

    [00:15:08.679]
    be able to view that photo offline so

    [00:15:11.800]
    everything we’re doing here is available

    [00:15:13.809]
    both online and offline so I’m going to

    [00:15:18.220]
    hit new page and this brings up a number

    [00:15:20.199]
    of page templates and page templates a

    [00:15:22.870]
    really quick way to build out your user

    [00:15:24.850]
    interface these page templates are based

    [00:15:27.220]
    on best practice patterns that are

    [00:15:29.259]
    developed by either your own

    [00:15:30.480]
    organizational UX team or developed by

    [00:15:33.399]
    the mendax apps team as well the UX team

    [00:15:35.709]
    here so we’re going to select responds

    [00:15:40.259]
    specific template here we’re also going

    [00:15:42.850]
    to select a particular layout and a

    [00:15:44.410]
    particular template to help speed up the

    [00:15:46.240]
    development

    [00:15:47.440]
    when I click show this will show the

    [00:15:49.509]
    page that we’ve just created and as you

    [00:15:51.879]
    can see here we have automatically

    [00:15:53.470]
    generated the structure based on that

    [00:15:56.290]
    particular entity so it already knows

    [00:15:58.779]
    because it’s inheriting the photo system

    [00:16:01.690]
    image we can automatically give the user

    [00:16:04.720]
    the ability to upload a photo be able to

    [00:16:07.149]
    select a question and also be able to

    [00:16:09.399]
    see that photo but I don’t want any of

    [00:16:12.100]
    this I want to have just the ability to

    [00:16:14.199]
    use the native camera and be able to

    [00:16:16.389]
    select and upload a photo so I’m going

    [00:16:19.750]
    to add on a new building block and the

    [00:16:21.430]
    building block I’m going to add on is

    [00:16:22.839]
    the camera option so here we have a

    [00:16:25.269]
    widget and a widget is an extension of

    [00:16:27.610]
    the mendax platform so you can extend

    [00:16:29.949]
    mendax one both from the front end with

    [00:16:31.810]
    custom javascript and build these into

    [00:16:34.089]
    widgets and also on the back end as well

    [00:16:36.670]
    so with custom java so with the widgets

    [00:16:39.790]
    capabilities are able to integrate into

    [00:16:42.009]
    native device functionality using the

    [00:16:44.649]
    Cordova framework to access certain

    [00:16:47.079]
    device features such as swipes such as

    [00:16:49.329]
    camera GPS and so on allowing you to

    [00:16:52.180]
    very rapidly use those features so in

    [00:16:56.319]
    this camera feature we want to be able

    [00:16:57.880]
    to view the image we want to be able to

    [00:17:00.639]
    save that particular photo and we want

    [00:17:03.579]
    to be able to upload that into our

    [00:17:05.199]
    application so I need to connect up the

    [00:17:09.490]
    Save button at the bottom here that have

    [00:17:11.110]
    automatically generated to our photo

    [00:17:12.909]
    entity and what this will do is once

    [00:17:15.970]
    we’ve taken the photo it will simply

    [00:17:17.650]
    save that into the database for us it

    [00:17:20.020]
    will save it into our offline database

    [00:17:22.659]
    if we’re offline if we’re online that

    [00:17:25.030]
    will automatically into the online

    [00:17:27.339]
    database so we’ve created our option now

    [00:17:32.890]
    and this will create a sofa to allow us

    [00:17:35.650]
    to take a photo and save that into our

    [00:17:38.200]
    application the next thing we want to do

    [00:17:40.690]
    is we want to be able to create a view

    [00:17:42.549]
    of all of those photos we want to be

    [00:17:44.500]
    able to see it gallery so that we can

    [00:17:46.330]
    see those images and view them in our

    [00:17:48.220]
    application so I’m going to create a new

    [00:17:51.100]
    page again and this time is going to be

    [00:17:53.500]
    to show the photos I’m going to create

    [00:17:58.419]
    form-based

    [00:17:59.320]
    use the same template

    [00:18:00.820]
    before and this time we’re going to just

    [00:18:02.920]
    show the photos options here I’m going

    [00:18:06.610]
    to give it a new page title which is

    [00:18:10.020]
    gallery and within here we can parse n

    [00:18:14.170]
    objects in this case we’re going to pass

    [00:18:15.880]
    the question because we want to be able

    [00:18:17.890]
    to see for each question all of the

    [00:18:20.380]
    photos that have been uploaded so I’m

    [00:18:23.320]
    going to add again another building

    [00:18:25.030]
    block and this time I’m going to use a

    [00:18:26.680]
    pictures building block which just comes

    [00:18:29.260]
    with a list view and our option to show

    [00:18:31.810]
    a photo so I’m going to connect this

    [00:18:34.420]
    ListView up here and the ListView allows

    [00:18:36.430]
    you to show a list of objects a list of

    [00:18:38.950]
    data that’s stored in a database or in

    [00:18:41.410]
    memory so in this case we’re going to

    [00:18:43.690]
    select a particular question and we’re

    [00:18:46.120]
    going to show all of the photos that are

    [00:18:48.190]
    available I’m also going to connect this

    [00:18:52.450]
    particular image up to our photo so that

    [00:18:57.310]
    we can show of view that particular

    [00:18:59.440]
    image I don’t need a Save button at the

    [00:19:03.340]
    bottom here so I’m just going to simply

    [00:19:04.750]
    remove that so that we don’t need a

    [00:19:06.460]
    button at the bottom page the next thing

    [00:19:12.160]
    I’m going to do is I’m going to build

    [00:19:13.660]
    some logic into the application so in

    [00:19:16.630]
    this logic I want to be able to when I

    [00:19:18.370]
    click this button I want to be able to

    [00:19:20.650]
    show and hide that notes field and we

    [00:19:23.110]
    want to be able to view that in our

    [00:19:25.510]
    application both online and offline

    [00:19:28.260]
    now we have two ways of building logic

    [00:19:30.880]
    in mendax we have mic flows which allow

    [00:19:33.970]
    you to build your visual logic for

    [00:19:36.250]
    online it will do those on the server

    [00:19:38.710]
    side for you but we also have the

    [00:19:40.750]
    concept of nano flows as well and nano

    [00:19:43.630]
    flows allow you to build logic in your

    [00:19:46.060]
    application which is completely run on

    [00:19:48.730]
    the client side of your application so

    [00:19:51.400]
    these can run both offline and online

    [00:19:53.470]
    these can be run in the browser that can

    [00:19:55.870]
    be run on the mobile device and these

    [00:19:57.940]
    allow you to build logic and navigation

    [00:20:00.400]
    and also decisions all within your

    [00:20:04.180]
    client side of your application so in

    [00:20:06.940]
    this case this particular nano flow is

    [00:20:08.770]
    checking to see whether our appointment

    [00:20:11.320]
    is complete so the appointment is only

    [00:20:13.660]
    complete

    [00:20:14.380]
    if we’ve actually completed all of the

    [00:20:15.910]
    topics and all of the questions within

    [00:20:17.920]
    that particular topic once it’s complete

    [00:20:20.860]
    we’ll then look for the next topic is

    [00:20:23.410]
    available in our offline database or

    [00:20:25.900]
    online if we’re online and it will then

    [00:20:28.510]
    set the next appointment in the list so

    [00:20:31.150]
    we showed earlier that top appointment

    [00:20:33.010]
    is our next appointment that will get

    [00:20:34.900]
    executed and run in our application so

    [00:20:37.800]
    let’s create a simple nano flow to be

    [00:20:40.750]
    able to actually show and hide this

    [00:20:42.760]
    notes field here so we’re going to

    [00:20:44.980]
    create Colin and a flow I’m going to

    [00:20:47.410]
    create a new nano flow and I’m going to

    [00:20:56.830]
    create some logic to show and hide that

    [00:20:59.230]
    particular question so here we have the

    [00:21:02.890]
    question we can then add some some

    [00:21:05.980]
    decisions to it so the first decision we

    [00:21:08.140]
    want to do is we want to check whether

    [00:21:09.490]
    the notes field is actually shown or

    [00:21:13.240]
    height so we have a balloon in our

    [00:21:15.670]
    database that we’ve already created and

    [00:21:17.380]
    this allows us to show and hide certain

    [00:21:20.080]
    elements on our particular page so we’re

    [00:21:22.990]
    going to say is the notes field shown

    [00:21:29.580]
    and we can do true or false values so

    [00:21:32.890]
    here we’re making certain decisions in

    [00:21:34.660]
    our application logic and based on that

    [00:21:37.210]
    flow we can then influence what we do so

    [00:21:40.510]
    if the the notes field is is shown we

    [00:21:43.540]
    want to them be able to hide it so the

    [00:21:45.610]
    same button we click it we want to be

    [00:21:47.650]
    able to show and hide that that notes

    [00:21:49.810]
    field so to do that we can use a change

    [00:21:53.110]
    object here and we can choose to select

    [00:21:56.230]
    a particular attribute and change the

    [00:21:58.570]
    value for that attribute so if it’s set

    [00:22:02.230]
    to true we want to set that particular

    [00:22:04.240]
    value to false and we also want to

    [00:22:07.870]
    commit this into the database if we have

    [00:22:10.000]
    on line connection if not we can commit

    [00:22:12.340]
    that into the offline database if if we

    [00:22:19.330]
    don’t show that half of the fields we

    [00:22:20.950]
    want to be able to actually show them

    [00:22:23.290]
    now so we want to be able to set this

    [00:22:24.760]
    one to true so I’m going to do a change

    [00:22:26.920]
    object again

    [00:22:28.030]
    on the same value it’s a very simple

    [00:22:33.550]
    logic to show you how you can make a

    [00:22:35.350]
    decision how you can change data all

    [00:22:37.870]
    within your application both online and

    [00:22:40.300]
    offline so we’ve made those changes now

    [00:22:45.580]
    and we can actually start to run and

    [00:22:47.890]
    view that application so the last thing

    [00:22:50.950]
    we need to do before we move on to

    [00:22:52.930]
    running application is we need to set

    [00:22:54.820]
    the visibility of this element so we

    [00:22:57.400]
    want to set this based on an attribute

    [00:22:58.930]
    we want to set the visibility of what

    [00:23:01.060]
    the user sees and with each page of

    [00:23:03.220]
    amend X you can conditionally show an ID

    [00:23:05.410]
    certain attributes based on data but

    [00:23:08.410]
    also based on module roles and user

    [00:23:10.270]
    roles in your application so when we

    [00:23:13.060]
    select true we want to be able to see

    [00:23:14.980]
    this notes field and one way to select

    [00:23:16.540]
    false we don’t want to be able to see it

    [00:23:20.820]
    so what I’m going to do now is I’m going

    [00:23:22.840]
    to hit the run locally button and in the

    [00:23:25.030]
    background what mendax does is it builds

    [00:23:26.590]
    us our application it will build the

    [00:23:29.080]
    database for us it will build the logic

    [00:23:31.090]
    layer and also any pages that we need to

    [00:23:33.790]
    interact with once it’s built we can

    [00:23:36.460]
    then view this application on our mobile

    [00:23:38.230]
    device allowing us to scan a particular

    [00:23:40.990]
    QR code so that we can test this

    [00:23:43.240]
    application both online and offline so

    [00:23:49.240]
    what the application will do is it will

    [00:23:50.590]
    ask us to synchronize the app because

    [00:23:53.230]
    there’s been changes to the database and

    [00:23:55.210]
    it will then make all of those updates

    [00:23:57.580]
    for us so it will do all of the creation

    [00:23:59.920]
    of the tables altering any names of

    [00:24:02.140]
    attributes and so on or within our

    [00:24:03.970]
    application so when we hit the down

    [00:24:07.180]
    arrow on this view option we have a few

    [00:24:09.190]
    options to view your application we can

    [00:24:11.500]
    either view it in our browser we can

    [00:24:13.090]
    view it on a mobile device but we also

    [00:24:15.400]
    have the ability to view it in the

    [00:24:17.080]
    mendax app and the mendax app is an app

    [00:24:19.750]
    that we can download from the App Store

    [00:24:21.310]
    and it allows you to test out those

    [00:24:23.410]
    applications without deploying and

    [00:24:25.360]
    bundling up your application so rather

    [00:24:28.120]
    than having to build those each time for

    [00:24:30.100]
    different devices you can simply use the

    [00:24:32.650]
    amended mobile app to test out those

    [00:24:34.660]
    applications and very rapidly confirm

    [00:24:37.150]
    that your application is built correctly

    [00:24:41.320]
    so using the MINIX mobile app we can go

    [00:24:43.000]
    into the side menu here we can click the

    [00:24:45.340]
    scan QR code this will bring up the QR

    [00:24:48.340]
    code for us where we can scan that

    [00:24:50.200]
    particular application and we can open

    [00:24:52.360]
    up that mobile application on our device

    [00:24:54.490]
    what it first do is have update the

    [00:24:56.830]
    application and load everything we need

    [00:24:58.750]
    because we’ve selected the use offline

    [00:25:00.880]
    profile allowing us to use this

    [00:25:03.460]
    application both online and offline so

    [00:25:08.740]
    here is our application we can see the

    [00:25:10.600]
    appointments overview we can see the

    [00:25:12.250]
    syrup ointments and when we go into the

    [00:25:14.350]
    view options here we can see those

    [00:25:16.600]
    information we can see the tasks and we

    [00:25:19.690]
    can then slide these information and we

    [00:25:22.210]
    have the options that we’ve built

    [00:25:23.529]
    earlier so let’s take a photo let’s open

    [00:25:26.470]
    up the camera and let’s take a selfie

    [00:25:40.500]
    and let’s hit save on that particular

    [00:25:42.850]
    photo so that we can save it into our

    [00:25:44.830]
    application if we go into the gallery

    [00:25:46.779]
    now we can see that particular photo

    [00:25:48.400]
    we’ve uploaded for that question

    [00:25:50.020]
    if we go on to other questions we won’t

    [00:25:51.970]
    see those particular photos because we

    [00:25:54.039]
    haven’t uploaded those and then finally

    [00:25:56.380]
    we can see this particular notes build

    [00:25:58.150]
    when we press it it will open and close

    [00:26:00.159]
    based on those options so as I said we

    [00:26:06.070]
    build this application very quickly

    [00:26:07.450]
    obviously you can see online at the

    [00:26:09.250]
    moment but let’s take that application

    [00:26:10.690]
    offline and put it in airplane mode to

    [00:26:13.779]
    show you how this application runs

    [00:26:15.309]
    exactly the same on our mobile device so

    [00:26:18.789]
    we’ve not built different interfaces

    [00:26:20.110]
    we’re not build different logic use the

    [00:26:22.179]
    same logic same interface to build both

    [00:26:24.070]
    online and offline

    [00:26:25.409]
    so let’s go ahead and take a photo again

    [00:26:32.789]
    let’s save that and now we can see we’ve

    [00:26:37.149]
    got these additional photos now so all

    [00:26:39.010]
    offline you’ve added that photo we have

    [00:26:41.049]
    the logic as well we can enter and save

    [00:26:43.360]
    these data we can even complete tasks on

    [00:26:48.640]
    the go whilst we’re viewing the

    [00:26:50.529]
    application so we see we’ve finished

    [00:26:53.140]
    this particular application because

    [00:26:54.429]
    we’ve hit complete it will work out what

    [00:26:56.470]
    particular point in is next and allow us

    [00:26:58.570]
    to view that in our application so now

    [00:27:04.419]
    that we’ve built that functionality we

    [00:27:06.100]
    might want to be answer deploy this out

    [00:27:07.720]
    to the mobile app stores so when

    [00:27:10.090]
    deploying applications especially for

    [00:27:12.279]
    iOS and Android it can often be very

    [00:27:14.230]
    cumbersome to build those packages

    [00:27:16.029]
    deploy those out to different devices

    [00:27:17.580]
    get the approval and so on in mendax we

    [00:27:20.679]
    try to make it as straightforward as

    [00:27:22.210]
    possible so as mentioned in the mendax

    [00:27:25.929]
    platform we have the one-click

    [00:27:27.309]
    deployment process so we can deploy to

    [00:27:29.710]
    any cloud or on-premise environment just

    [00:27:31.539]
    by hitting the run and when we hit run

    [00:27:33.669]
    this will take all of the changes we’ve

    [00:27:35.470]
    made to our application commit those

    [00:27:37.690]
    into our central repository making them

    [00:27:40.029]
    available for our developers so out of

    [00:27:42.730]
    the box mendax comes with a team server

    [00:27:44.440]
    which is a central repository based on

    [00:27:46.899]
    SVN allowing multiple developers to work

    [00:27:49.659]
    on the same project create branch lines

    [00:27:51.580]
    and so on deploy their application

    [00:27:54.259]
    so that our application is deploying to

    [00:27:56.909]
    our server we might want to package out

    [00:27:59.009]
    our application and make it deplorable

    [00:28:01.169]
    to our native device so to do so we can

    [00:28:04.529]
    go over to the mendax project space and

    [00:28:07.919]
    this is something we covered in a

    [00:28:09.089]
    previous webinar and the mendick project

    [00:28:11.909]
    space allows you to collaborate with

    [00:28:13.859]
    people within your project allow you to

    [00:28:16.019]
    develop out your application but also

    [00:28:18.029]
    deploy your application out to many

    [00:28:19.919]
    mobile devices as well so if we go to

    [00:28:22.649]
    the mobile app section here this is

    [00:28:25.109]
    where we can start to package out and

    [00:28:26.729]
    build our applications for those native

    [00:28:28.679]
    devices so whether it be iOS or Android

    [00:28:31.589]
    we can set certain configurations in

    [00:28:34.349]
    this application and also certain

    [00:28:36.359]
    permissions for camera and calendar

    [00:28:38.399]
    within this app we can select certain

    [00:28:41.609]
    colors and themes for our application as

    [00:28:43.709]
    well as add in certain logos in this

    [00:28:46.739]
    case we’re just going to build for

    [00:28:47.999]
    Android and to build our application the

    [00:28:51.599]
    mendax application uses the Cordova

    [00:28:54.119]
    framework so we wrap her up those

    [00:28:56.609]
    applications using html5 and we use the

    [00:28:59.459]
    Cordova framework to allow us to

    [00:29:00.869]
    integrate into those native device

    [00:29:02.849]
    functionalities and to build those

    [00:29:05.579]
    applications we’ve built a online cloud

    [00:29:07.709]
    service allowing you to build your

    [00:29:10.169]
    applications in the cloud using PhoneGap

    [00:29:12.839]
    build services so if we hit publish to

    [00:29:15.749]
    mobile app stores well this will do is

    [00:29:17.669]
    it ask us whether we want to build this

    [00:29:19.139]
    locally ourselves or build in the clouds

    [00:29:21.629]
    and which environment we also want to

    [00:29:24.059]
    build for if we hit this start PhoneGap

    [00:29:27.389]
    build job what this will do is we’ll

    [00:29:29.039]
    take that application for us build us a

    [00:29:31.109]
    necessary Cordova package transport that

    [00:29:34.079]
    to the PhoneGap build service which will

    [00:29:36.119]
    then start to build that in the cloud

    [00:29:37.679]
    for us now if we head over to a friend

    [00:29:41.219]
    gap build we’ll see that our new

    [00:29:42.659]
    application is starting to be built this

    [00:29:45.749]
    will allow us to then scan a QR code so

    [00:29:48.599]
    we can install it on our device and then

    [00:29:51.209]
    use that as a device application on our

    [00:29:53.639]
    mobile phone so we can see here that our

    [00:29:57.929]
    mobile application for the Android is

    [00:29:59.969]
    complete and we’ve built that new

    [00:30:01.829]
    package for the mobile device

    [00:30:04.740]
    if we click on the mobile experiences

    [00:30:06.630]
    overview here we can see and we can

    [00:30:08.370]
    download the apk which is used to

    [00:30:10.860]
    install on the mobile Android device and

    [00:30:13.380]
    in the top right hand corner we have a

    [00:30:15.240]
    QR code and if we bring up our phone

    [00:30:17.880]
    that we had earlier we can go into a

    [00:30:20.070]
    particular scanner and we can scan that

    [00:30:22.320]
    QR code so that we can install it on our

    [00:30:24.419]
    device

    [00:30:25.140]
    so we’ve open that QR code scanner we

    [00:30:27.630]
    can scan it here it will ask us to

    [00:30:30.799]
    download a particular application and

    [00:30:33.690]
    here we can see we can download the löwe

    [00:30:36.419]
    code mobile experiences app we hit

    [00:30:39.570]
    downloads and this will then ask us to

    [00:30:42.270]
    open up and install the device so if we

    [00:30:46.289]
    hit install this will take that

    [00:30:47.850]
    application it will install it on our

    [00:30:49.559]
    Android device there so that we can then

    [00:30:51.750]
    start to use the native device features

    [00:30:53.700]
    and we can then use the features from

    [00:30:56.130]
    our sandbox server as well so the app is

    [00:30:59.730]
    now installed and we can open up the

    [00:31:02.190]
    application and view that application

    [00:31:04.409]
    using the data from our sandbox

    [00:31:06.240]
    environment so very quickly we’ve been

    [00:31:09.210]
    able to one-click deploy into our

    [00:31:11.370]
    sandbox environment be able to package

    [00:31:14.010]
    up our applications for the mobile app

    [00:31:15.840]
    stores and be able to then install it on

    [00:31:18.480]
    an actual device without application and

    [00:31:21.480]
    view the data within it so we can see

    [00:31:23.610]
    here we’ve got our appointments we can

    [00:31:25.260]
    start an appointment view the upcoming

    [00:31:27.600]
    appointments all within the platform so

    [00:31:32.429]
    the final point I want to cover is how

    [00:31:34.080]
    we can actually extend them index

    [00:31:35.549]
    application with a set of services and

    [00:31:37.470]
    use it as a mobile backend as a service

    [00:31:40.730]
    so back into the platform we can easily

    [00:31:43.679]
    create any rest service or soap service

    [00:31:46.440]
    which we can expose out to a set of

    [00:31:49.110]
    interfaces so whether that be on your

    [00:31:52.289]
    mobile wearable device or whether it be

    [00:31:54.000]
    on your coded device on iOS or Android

    [00:31:56.669]
    we can expose that out using a set of

    [00:31:59.580]
    services so the first thing we need to

    [00:32:02.100]
    do is we need to create our published

    [00:32:03.570]
    rest service we can call it appointments

    [00:32:08.870]
    click ok and within here we have the

    [00:32:12.480]
    ability to start building out the

    [00:32:14.100]
    resources and the data that we want to

    [00:32:15.899]
    expose as a service now in mendax we

    [00:32:18.780]
    made that easy all we need to do is we

    [00:32:20.970]
    need to go to the connector and if we

    [00:32:22.740]
    want to drag on and create a service for

    [00:32:24.810]
    our appointments we can simply drag that

    [00:32:26.460]
    on to our workbench here we can select a

    [00:32:29.010]
    particular key attribute and the key HP

    [00:32:31.710]
    allows us to search for certain certain

    [00:32:35.070]
    appointments or certain information in

    [00:32:37.320]
    our data and when we select a particular

    [00:32:39.720]
    key appointment and we select our

    [00:32:41.700]
    operations we can click OK and this will

    [00:32:44.550]
    automatically generate us all of the

    [00:32:46.410]
    necessary rest services the mappings

    [00:32:49.110]
    there Mike flows behind this particular

    [00:32:51.180]
    api’s to be able to call those

    [00:32:53.640]
    interfaces the next bit is if I click

    [00:32:57.300]
    run locally what this would do is it

    [00:32:59.520]
    will now build us a swagger definition

    [00:33:01.830]
    for this rest service meaning that we

    [00:33:04.230]
    can take any swagger information we can

    [00:33:07.140]
    then build a code generation using

    [00:33:09.840]
    swagger koujun for instance to be able

    [00:33:12.390]
    to integrate into our mendax application

    [00:33:14.820]
    making it very easy to expose these

    [00:33:17.730]
    applications out and utilize them only

    [00:33:20.250]
    for the backend or logic so you have the

    [00:33:22.650]
    true flexibility of being able to build

    [00:33:24.420]
    those user interfaces on the mendax

    [00:33:27.000]
    platform but also outside of the

    [00:33:29.070]
    platform and use them via services so if

    [00:33:33.030]
    we hit view and we go to slash rest

    [00:33:36.000]
    slash doc we can see our services that

    [00:33:39.510]
    we’ve published in the rest services and

    [00:33:41.880]
    we click on this we can see our swagger

    [00:33:43.500]
    definition that have been created we can

    [00:33:45.780]
    see each the services so I’ll get our

    [00:33:47.880]
    post and delete operations and we can

    [00:33:51.090]
    add easily additional operations in here

    [00:33:53.580]
    as well if we for instance click try out

    [00:33:56.730]
    and click execute this would give us an

    [00:33:58.800]
    example curl call or an example service

    [00:34:01.650]
    response that we can use to integrate

    [00:34:03.750]
    into our service so if we take this curl

    [00:34:06.330]
    response for instance we can paste this

    [00:34:08.040]
    into our favorite Linux service for

    [00:34:10.620]
    instance in this case I’m using Ubuntu

    [00:34:13.040]
    and we can then paste that into there so

    [00:34:15.840]
    that we can actually see the response we

    [00:34:17.460]
    get back so this is the live data I have

    [00:34:19.440]
    from our local server and very quickly

    [00:34:21.690]
    spin that up and utilize that there’s

    [00:34:23.700]
    data in my other applications so just to

    [00:34:27.030]
    summarize in the last 30 minutes what

    [00:34:29.550]
    we’ve shown you is how to take any

    [00:34:31.909]
    listing application and make a change to

    [00:34:33.679]
    it how to deploy that application and

    [00:34:36.289]
    utilize the services like the mendax

    [00:34:38.809]
    mobile to be able to test your

    [00:34:40.190]
    application now both on online and also

    [00:34:43.309]
    being able to test it offline as well

    [00:34:45.530]
    and we’ve also shown you how you can

    [00:34:47.929]
    make mendax into a mobile back in this

    [00:34:50.059]
    service simply by exposing rest services

    [00:34:53.030]
    out by drag and drop so hopefully this

    [00:34:57.260]
    has been of interest and hopefully you

    [00:34:58.700]
    join us for the next webinar will now

    [00:35:00.710]
    hand over to the live Q&A so at this

    [00:35:10.430]
    stage of the webinar we’re going to move

    [00:35:12.020]
    over to our Q&A portions just just a

    [00:35:16.160]
    couple quick notes looking at some of

    [00:35:18.049]
    the questions that have come in if you

    [00:35:20.180]
    do have specific product implementation

    [00:35:23.569]
    questions a great resource is going to

    [00:35:26.480]
    be our our mendax forum forum and XCOM

    [00:35:29.980]
    that’ll provide you with a lot of

    [00:35:32.500]
    questions that people have already asked

    [00:35:34.579]
    as well as you can post your own and

    [00:35:35.960]
    people get back to you very quickly

    [00:35:38.809]
    we’ll keep we’ll keep these questions to

    [00:35:41.380]
    be a little bit more broad and applied

    [00:35:44.089]
    to all of our listeners something else

    [00:35:47.420]
    one of the questions in there was on our

    [00:35:49.339]
    recordings and the previous showings of

    [00:35:51.470]
    this webinar they are available on the

    [00:35:53.660]
    website if you go to mendax calm in the

    [00:35:55.609]
    top right corner you click demos it’ll

    [00:35:58.640]
    show you all the recordings we’re

    [00:36:00.440]
    actually in the middle of the redesign

    [00:36:01.700]
    of that so to make it a little bit more

    [00:36:03.289]
    accessible and easier to find the videos

    [00:36:05.720]
    you want and that’ll be coming out this

    [00:36:08.599]
    week but for now you can go there and

    [00:36:10.309]
    pretty quickly find what you’re looking

    [00:36:12.049]
    for I’m jumping right into it as we do

    [00:36:14.809]
    have a number of questions and not a

    [00:36:17.150]
    whole lot of time left the first

    [00:36:19.579]
    question that I’m seeing here is asking

    [00:36:22.250]
    if it’s possible to build extensions to

    [00:36:24.529]
    utilize native device features yes so we

    [00:36:29.450]
    can build extensions using widgets

    [00:36:31.730]
    widgets are based on JavaScript and we

    [00:36:35.180]
    can utilize any Cordova library to

    [00:36:37.640]
    integrate into the native device

    [00:36:39.289]
    functionality so once you’ve wrote that

    [00:36:41.270]
    particular widget once you can reuse it

    [00:36:43.849]
    across all of you

    [00:36:45.190]
    and with widgets you can pass data from

    [00:36:48.160]
    the Mende application so that you can

    [00:36:50.170]
    add that level of data to your

    [00:36:52.660]
    integration into the service from the

    [00:36:55.540]
    phone device rolling right along next

    [00:37:01.660]
    question is asking how I can update the

    [00:37:03.670]
    colors in design of my applications it’s

    [00:37:08.290]
    an every mendax application comes with a

    [00:37:10.569]
    theme package and the bean package

    [00:37:12.910]
    allows you to design what your

    [00:37:14.380]
    application is going to look like in

    [00:37:15.880]
    terms of your colors your design what

    [00:37:18.220]
    you’ll see on the screen and you can

    [00:37:20.140]
    easily customize that either using

    [00:37:22.000]
    artists fast that’s built into the

    [00:37:24.069]
    product so you can change using

    [00:37:25.660]
    variables but we also have an online

    [00:37:27.880]
    theme customizer as well so using the

    [00:37:30.190]
    theme customizer you can upload a

    [00:37:32.380]
    particular logo you can change colors

    [00:37:34.780]
    and parameters all online and then you

    [00:37:36.940]
    can then apply that design to your

    [00:37:38.589]
    application that we use CSS and html5 to

    [00:37:42.250]
    present the information so you can

    [00:37:44.560]
    easily change those and the theme

    [00:37:46.329]
    package okay the next question I have

    [00:37:54.700]
    here is can mendax applications be

    [00:37:57.579]
    distributed using a mobile device and

    [00:38:00.190]
    management yes so the same process I

    [00:38:04.930]
    showed you earlier where you can deploy

    [00:38:07.060]
    and build your application once you’ve

    [00:38:09.280]
    built your APK for Android in your IPA

    [00:38:12.310]
    for iOS you can then run for those using

    [00:38:15.400]
    a mobile device management system

    [00:38:17.170]
    something like a mobile iron for

    [00:38:19.329]
    instance and you can then distribute

    [00:38:20.950]
    that out to your enterprise devices so

    [00:38:24.369]
    that you can easily create new updates

    [00:38:26.619]
    and distribute them without going

    [00:38:28.540]
    through the app store process the next

    [00:38:35.530]
    question here without giving away any

    [00:38:37.380]
    roadmap items is there a mac app for

    [00:38:41.470]
    Minich

    [00:38:42.960]
    apparently there’s a web-based version

    [00:38:45.849]
    which we showed in a previous webinar

    [00:38:48.359]
    and in that webinar you can that we show

    [00:38:51.700]
    you how to build an application using

    [00:38:53.170]
    the visual models of the web model of

    [00:38:55.300]
    the same model is exactly the same in

    [00:38:58.599]
    Tobler as it is in the web board love

    [00:39:00.729]
    you can start off with the web modeler

    [00:39:02.470]
    and build your application there and

    [00:39:04.059]
    synchronize it with the desktop

    [00:39:05.680]
    environment the desktop environment does

    [00:39:07.690]
    work on on parallels or on a VM on a map

    [00:39:11.680]
    and so that’s probably the best approach

    [00:39:13.390]
    at the moment to go down the next

    [00:39:21.249]
    question I have here is are the UI

    [00:39:23.529]
    controls mendax developed and supported

    [00:39:27.839]
    are they mimics development spíritus yes

    [00:39:31.630]
    so there’s a number of key you are

    [00:39:33.579]
    components which are core and supported

    [00:39:36.609]
    by the manage products and surveys are

    [00:39:38.950]
    things like the list views the data

    [00:39:41.079]
    views that I show to drag on the buttons

    [00:39:43.150]
    and so on they’re all supported out the

    [00:39:44.829]
    box of the minutes platform we then have

    [00:39:47.200]
    the Domenic’s app store where there’s a

    [00:39:49.630]
    further set of components which you can

    [00:39:51.700]
    download and add into your product a

    [00:39:53.380]
    number of those components are supported

    [00:39:55.809]
    at the platform level do you can

    [00:39:57.700]
    download those and use those and amend X

    [00:40:00.430]
    will make sure that every release those

    [00:40:02.289]
    particular widgets are updated and they

    [00:40:05.200]
    work in the latest release and there’s

    [00:40:07.420]
    also a number of community widgets on

    [00:40:09.819]
    the App Store so these are highlighted

    [00:40:11.859]
    very clearly on the App Store as to

    [00:40:13.359]
    which ones are platform level which ones

    [00:40:15.039]
    are community level and you can download

    [00:40:17.140]
    those and use those in your project so

    [00:40:24.099]
    we are seeing a lot of questions coming

    [00:40:26.349]
    in I do want to note that if you have

    [00:40:29.259]
    any questions

    [00:40:30.369]
    a please feel free to write them in the

    [00:40:32.589]
    Q&A box on your on the dashboard any

    [00:40:35.920]
    question that we’re not able to get to

    [00:40:37.930]
    within this session and we have just a

    [00:40:41.019]
    few minutes left we will followup with

    [00:40:43.749]
    after the session at some point today so

    [00:40:46.599]
    that your questions are all answered and

    [00:40:48.489]
    you can speak with someone if you have

    [00:40:50.769]
    further questions going back up to the

    [00:40:53.440]
    top of from the questions that have come

    [00:40:55.150]
    in just in the last few minutes

    [00:40:58.029]
    it seems Java as a knowledge it’s very

    [00:41:01.239]
    nice to have though I have been told you

    [00:41:03.369]
    do not need any code or design knowledge

    [00:41:06.190]
    so I’m can you speak just a little bit

    [00:41:08.589]
    about our sort of developer spectrum yes

    [00:41:12.570]
    with the amendment platform we try to

    [00:41:14.890]
    support all types of developers within

    [00:41:17.020]
    your organization’s everything from

    [00:41:19.359]
    someone that’s never developed before

    [00:41:21.010]
    they can use the web modelers to be able

    [00:41:23.080]
    to quickly build an application and be

    [00:41:24.849]
    able to drag the drop and build

    [00:41:26.740]
    application out we then have the desktop

    [00:41:29.170]
    modeler which we focus more at your

    [00:41:30.790]
    business analyst toward more traditional

    [00:41:33.040]
    developers who want to be able to do

    [00:41:34.810]
    things like integration they want to be

    [00:41:36.730]
    able to do code extensions and so on and

    [00:41:38.770]
    utilize those in the model but then the

    [00:41:40.900]
    same model can also be opened up in an

    [00:41:43.060]
    ID as well so using a Java ID you can

    [00:41:46.000]
    build extensions on the backend they

    [00:41:48.040]
    utilize the same application model and

    [00:41:50.410]
    the same data using the runtime api we

    [00:41:54.250]
    really try to span the whole spectrum of

    [00:41:56.470]
    types of developers in the organization

    [00:41:58.359]
    from people that have you know mess

    [00:42:00.730]
    around with building access databases

    [00:42:02.950]
    and Excel databases through to your

    [00:42:05.560]
    traditional developers and we have all

    [00:42:07.119]
    the different products to support that

    [00:42:14.730]
    and then Alyssa how does mendax mobile

    [00:42:18.430]
    development compare to progressive web

    [00:42:21.250]
    app media is it possible to emit app

    [00:42:24.460]
    stores and install it as PWS they’re

    [00:42:29.109]
    currently PWA they aren’t supported with

    [00:42:31.180]
    them index platform I’m not saying that

    [00:42:33.460]
    it won’t be in the future but at the

    [00:42:35.410]
    moment we support the as crona’s via

    [00:42:38.109]
    there’s and wrapper so using the Cordova

    [00:42:40.540]
    wrapper

    [00:42:41.170]
    the advantage of doing a deployment of

    [00:42:43.570]
    our mandates is that you only need to

    [00:42:45.130]
    deploy to the app stores once once

    [00:42:48.070]
    you’ve deployed to the App Store you can

    [00:42:49.570]
    then also utilize those native device

    [00:42:51.730]
    features and any updates will

    [00:42:53.560]
    automatically push using over hair

    [00:42:56.859]
    update it will pull those new changes

    [00:42:59.080]
    into the application so you don’t

    [00:43:02.020]
    necessarily have to if you want to build

    [00:43:03.790]
    a mobile application then yes you need

    [00:43:06.670]
    to go through the absol process if

    [00:43:08.619]
    you’re building a online browser mobile

    [00:43:11.050]
    application that doesn’t necessarily

    [00:43:12.640]
    need to use things like push

    [00:43:15.070]
    notifications or things like

    [00:43:16.950]
    accelerometers and so on then you can

    [00:43:19.060]
    build a web application which runs on

    [00:43:22.420]
    the the mobile browser as well

    [00:43:24.359]
    a tablet but it’s exactly the same model

    [00:43:26.609]
    you can build exactly the same app for

    [00:43:29.579]
    both online offline or mobile but more

    [00:43:32.190]
    so on responsive web as well yeah so I’m

    [00:43:38.730]
    just for for a few more questions so

    [00:43:40.739]
    well I’ll give you a lay up here that’s

    [00:43:44.759]
    American for an easy question all right

    [00:43:47.999]
    so translations are there provisions for

    [00:43:52.019]
    free training and certification on

    [00:43:53.910]
    mending software yes there are so if you

    [00:43:58.470]
    go to Academy minutes comm you can go

    [00:44:01.529]
    through the free online training so all

    [00:44:03.569]
    of our introduction training is

    [00:44:04.829]
    available online after you’ve gone

    [00:44:07.319]
    through that particular training and you

    [00:44:09.239]
    can then take the mendax beginners rapid

    [00:44:12.960]
    developer certificate sorry once you’ve

    [00:44:15.599]
    got that ticket you then become a rapid

    [00:44:18.029]
    developer and then we have further

    [00:44:19.710]
    courses to take the on to be an advanced

    [00:44:22.259]
    user as well which is also online so all

    [00:44:25.079]
    the examinations all of the training is

    [00:44:26.730]
    free available online as well as the

    [00:44:29.309]
    modular development tool I showed you

    [00:44:31.109]
    earlier you can download today and build

    [00:44:33.359]
    unlimited applications for free and we

    [00:44:35.819]
    host those for up to 10 users okay thank

    [00:44:40.589]
    you know the last question I have here

    [00:44:42.599]
    that we’re going to be able to cover the

    [00:44:44.849]
    question is what type of integration do

    [00:44:47.069]
    you have with the s AP cloud platform

    [00:44:50.480]
    okay so this is a slightly different

    [00:44:54.450]
    from the mobile questions but mendax

    [00:44:56.730]
    obviously is a solution extension

    [00:44:58.739]
    partner of s AP which means we can add

    [00:45:02.039]
    deploy onto the ASAP cloud platform and

    [00:45:04.710]
    utilize any of the services that have

    [00:45:06.960]
    belonged to the SP platform so we can

    [00:45:09.450]
    easily integrate into services such as

    [00:45:11.519]
    ECC we can integrate into s for success

    [00:45:15.450]
    factors concur and SOP leonardo services

    [00:45:19.319]
    from the blockchain the IOT services

    [00:45:21.329]
    that sort of thing easily with the

    [00:45:23.430]
    integration so some of these

    [00:45:24.660]
    integrations are available on the mendax

    [00:45:26.759]
    app store but what we’ve also built with

    [00:45:29.009]
    the partnership of sfe is that we’ve

    [00:45:30.749]
    built the ability to generate any

    [00:45:32.759]
    integration into any of the s AP systems

    [00:45:35.220]
    using our OData

    [00:45:36.900]
    food

    [00:45:38.070]
    using Ennio data all breasts service we

    [00:45:40.770]
    can automatically generate the necessary

    [00:45:42.450]
    data structure and mapping to the mendax

    [00:45:45.060]
    application so that you can communicate

    [00:45:46.830]
    with that particular service and we also

    [00:45:49.740]
    have a number of services which are

    [00:45:52.260]
    automatically set up when you connect

    [00:45:53.940]
    and deploy a DSP cloud platform such as

    [00:45:56.280]
    the connectivity services and the single

    [00:45:58.830]
    sign-on services duty you can auto you

    [00:46:01.680]
    can utilize those particular api’s and

    [00:46:04.050]
    services that are within your

    [00:46:05.340]
    organization without the neither have to

    [00:46:08.340]
    configuring create certain collections

    [00:46:10.830]
    into S&P products well we’re actually a

    [00:46:17.130]
    little bit over a minute over time now

    [00:46:19.890]
    so we’ll wrap it up there just to

    [00:46:21.600]
    reiterate we will follow up with any

    [00:46:23.610]
    questions that we weren’t able to get to

    [00:46:25.200]
    during this session thanks everybody for

    [00:46:27.480]
    attending Simon thank you for presenting

    [00:46:29.730]
    the demo force thank you have a good one