Building Mobile Experiences

• App Development
• Mobile

• 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