00:01Okay. So we've had a good look at how you build an application, how you construct the map...

00:06...how you author your content for the map and just build that up, and how you're going to interact with it.

00:11This map overlay, it's critical to the way that you interact with it, what you...

00:15...the mouse clicks you're going to perform on that map for your business operation.

00:20And then we had a good look at deployment.

00:21So think about this deployment again when we're going through the rest of part II...

00:27...because there's some extra functionality you kind of need to be aware of and think about.

00:32So I thought we could just take a step back and have a look at this local server, have a look at how is it built...

00:38...what does it consist of, what do you need to know about it to make your applications perform really well?

00:43Then we're going to go and look at analysis, have a look at a framework for doing analysis online and local layers.

00:50In particular, look at editing and then finish up and just talk a bit more about this product summary.

00:56As I said at the beginning, I actually don't have any prices...

00:58...but you can get some idea of what the business model's going to be in terms of relationship to MapObjects and Engine as well.

01:06So let's have a look at that.

01:09Right. The local server and the services, right.

01:13So all GIS functionality is provided through the services, so whether they're online services or local services...

01:21...everything that you do, whether it's displaying maps, analyzing data, the geoprocessing service, geocoding service...

01:29...it all happens through these services.

01:31So it's good to know about those.

01:34And you have a new ArcGIS Runtime local server.

01:37There is no other products that have a local server.

01:40So it's just WPF and the Java SDK; those are really the only ones that have a local server at the present.

01:49Okay. So ArcGIS Runtime local server.

01:52You know it exists. You saw Ralf showing it to you.

01:56When he spun up the Task Manager, you could see some of those processes, so you kind of know that that exists.

02:03So access to this local server all happens through services, and these are the services we're supporting at present.

02:10So there's a mapping service, a feature service, geocoding, geoprocessing services.

02:15You can see there's some dots on there, so what does that mean?

02:18We are contemplating an image service in the future, maybe some kind of printing service...

02:22...so there's no printing at present for Java, but we are considering a print service.

02:28Okay. So how do we access these services?

02:31We access them all through the API, so you don't actively have to work with the services.

02:39You're basically working with the API onto those services and working with them.

02:48So those services are ArcGIS REST services, and they conform to the REST specification.

02:58So you can see from that diagram there's a clear separation between the API and the actual services themselves and the Runtime.

03:04So we can improve the performance of the Runtime, we can improve the performance of those services...

03:09...but have absolutely no impact on your API and the applications that you build.

03:13So with each individual release, we might be able to work on any of those components in the Runtime...

03:19...and the local server was one of them, and try and improve performance...

03:22...and work with the hardware, work with the graphics cards, et cetera, just to try and improve that.

03:28But your API, your functionality should not change, okay?

03:32It might change because there might be improved functionality, but it's separate from the services and the server.

03:39Okay. Sorry, there was something on that previous slide I just wanted to mention...and go back. Okay.

03:46So one application - sorry.

03:53What I want to say is when you're running your application, and it's usually on a local server...

03:57...that local server is dedicated to that application.

04:01If you run up two applications, you have two servers, and another server and another server.

04:05So that server is dedicated to the application that's running.

04:12Right. So you know there's an API, you know there are REST services, and you know that there's a local server...

04:17...but basically you can treat the server and the services as a black box.

04:21You just deal with the API and you interact with the server and the REST services separately as a single unit.

04:29So you just treat it just like a black box.

04:32So you build your application, you use the native API, you develop, you work with it...

04:38...and that API is talking just straight to those REST services.

04:41You don't need to know about that, but that is actually what's happening in the background.

04:46So that red service, when it wants to utilize the local server, is spinning up an embedded web server, okay?

04:54It's going to, if you then want to use the map service, for example, it's going to bring up a worker.

05:00If you want to do some geocoding, another worker and another worker.

05:04So each of these processes are being spun up as a sort of...

05:08...without you knowing about it, but they're being spun up in the background.

05:12Whoops. Okay. Okay. So then HTTP REST requests being sent between the client and the server itself.

05:22We're going to explore that a bit in a minute.

05:27So the first service is process 1, and you have a process for every single service that's being spun up.

05:36So the server itself has its own process, and then any other service that you spin up has its own service. Process, pardon me.

05:45And if you were to look in Task Manager, this is what they're called. They're called RuntimeLocalServer.exe.

05:50That's very useful to know because, I guess, if you ever hit any problems, you want to see what's going on...

05:55...see what's going on with memory, you can go into your Task Manager and look at the processes and see what's running.

06:04Okay. I'm sorry, sir?

06:09[Inaudible audience question]

06:13Absolutely not. This is not the same architecture for Server, for service.

06:18So it's not a SOC/SOM architecture; it is just a process managed architecture.

06:23So as I said, there's one application has its own server.

06:27That server is pretty much a number of processes that are running in the background.

06:33[Inaudible audience question]

06:37No, there's no extension to that tool. It is almost like a hidden set of processes that are operating.

06:44We're looking in the future to provide an extensibility framework, but it's not an ArcObjects-based extensibility framework.

06:52And that's way down the line. We're thinking about it.

06:57So I'm telling you it's a server, but it's almost like it's a black box. It's a hidden black box.

07:03You can see it, you can see it running, but you can't really utilize it. Okay?

07:08And one of the reasons you can't utilize it is because the HTTP request that's being spun up...

07:13...you can see at the bottom line, has a unique ID.

07:15So every application that runs, it has its own unique ID. Sorry - unique path for that HTTP request. Okay.

07:27So small overhead. And these things can, these services that you saw can run up and spin up asynchronously.

07:35So what are the security implications there?

07:38I've just said it's a server; what are the security implications?

07:40Okay, so there's no external port to it, and there is a unique URL for each instance...

07:46...so every time an application runs, it's creating a unique instance for that.

07:52Okay. So a server, but not as you know it.

07:57It's not a generic web server, it's not tunable, okay? It's not an embedded Tomcat service.

08:04It's not a lightweight version of an ArcGIS Server, so all the questions you just asked, it is not that.

08:10And each local server gets spun up for each application, and if you're going to deploy it...

08:17...if you're going to need to use local services, you need to make sure you deploy that local server.

08:21So if you remember the deployment list, you're using local services, just tick on that deployment option.

08:26Okay. You can control just one or two things.

08:30You can control, select the port range that you're going to utilize...

08:34...and you can actually choose to switch off that random prefix that's inside that URL.

08:39That's completely up to you if you want to do that or not.

08:43Okay. Ralf's going to give us a good demo of how the local server works and some of that functionality I just showed you.

08:52Okay, so here I've got an application that's just a window, and we've got a little text area here...

09:03...and these buttons just start up the local server.

09:06So I've got an API available to me that I can start up the local Runtime server.

09:11If I click Start Server, we see some output here.

09:14If I go to Task Manager, we can see that we have one RuntimeLocalServer executable running.

09:20That's the little mini server that hosts all the other worker processes, and it's got a very small memory footprint.

09:28And we purposely built this architecture like this because we wanted to leverage...

09:33We did a lot of research. Like, we thought initially...

09:36...Are we going to build one executable that spins up all these multiple threads and allows you to work with these services...

09:41...or do we want multiple executables? And we found that OSs handle executables better than multithreaded applications.

09:50So we decided to spin up multiple executables.

09:53What else is really cool about spinning up multiple executables, if one of these executables crashes for some unknown reason...

10:00...this server is real lightweight; doesn't really do much, just receives and sends requests down to the worker processes.

10:07If a worker crashes - which it should never crash; our software does not crash, no.

10:14If it does, the server knows everything it needs to know to spin up another worker process...

10:19...and there's logic in there; it'll just spin it right back up.

10:21And there's also logic that it won't just constantly do this in a never-ending loop...

10:25...but if it does crash, you still can work.

10:27So all you're going to see, maybe you won't see a map for a couple seconds and then you'll get it back.

10:32And, because it's in a separate process, it doesn't affect your application.

10:36So this is totally different than ArcObjects, which is really cool 'cause ArcObjects...

10:40...soon as you load in ArcObjects, your app increases maybe by 200 megs or something like that...

10:45...and now you're done with your mapping and your application, you can't reclaim that memory. It's gone. It's stuck.

10:53But with this local server architecture, you can shut down the services and reclaim all that memory right back.

11:00So here, I can start up a geocoding service.

11:03We see I've got another service that spins up, and all these services share memory.

11:08So looking in Task Manager at the real memory usages, never a good idea.

11:13They share memory, so they all share common DLLs, so the memory footprint actually is really small too.

11:18We did a lot of research on that, too, when we were designing this architecture.

11:23So then I can go ahead and spin up a map service, so I'll start the map service; there's another executable.

11:28And this map service, I can add a layer over here.

11:30I've got actually a JMap right here, so now I've got my little map in my application.

11:37Some services have multiple executables that spin up.

11:40Like a geoprocessing execute service only has one additional executable.

11:45A SubmitJob service will spin up two executables.

11:50One is the actual worker; the other one is a listener for that worker...

11:54...so that it allows you to ping the status of your geoprocessing task.

11:59And then there is a Geoprocessing Submit with Map Service Result, so it spins up a geoprocessor worker and a map service...

12:07...so whatever I get out of my geoprocessing service, I can then display on my map as a map service.

12:15But all of these services can just be shut down, and you can see that the executables start going away.

12:21For example, if I shut down my map service, my map goes away.

12:24I don't have a map anymore; I'm done with my GIS stuff and I've reclaimed all that memory...

12:30...and my application just continues to work fine. I don't have to do anything else.

12:35So I could stop them all at once by shutting down the local server.

12:38All the other processes go away, and we're done.

12:42So that's basically the architecture of the local server, and it's good to understand it...

12:48...so you know what you're doing when you're spinning up a map package.

12:51Why does it take a second? Well, we've got to spin up a process.

12:53But once that process is up, things happen really quickly.

12:58And it allows us to have this flexible architecture, leverage multiple cores, and with the asynchronous API...

13:03...you can actually do separate processing all at the same time.

13:11Okay. Good. Yes?

13:14[Inaudible audience question]

13:19That's all. Pass it back to Mary.

13:23With like Fiddler or something?

13:25[Inaudible audience question, continued]

13:27Oh, actually, yeah. I kind of forgot to do that.

13:31Let me start up the local server again, and you could see that I've got a URL right here.

13:40If I copy that and paste it into Internet Explorer...

13:45We've got an ArcGIS Runtime REST services directory, so if I go back here and then go...I've got my map service.

13:52If I start up my map service, as soon as the map service is started up, I refresh this, I can actually go explore my map service...

14:00...via ArcGIS REST services directory, look at the layers that are in this map service, and then, because it's all...

14:08The API allows you to communicate with Server, which is all through REST, locally you're going to be using URLs too.

14:17We allow you to actually look at the URL and look at the REST services directory so that you can explore your data...

14:24...and know how to interact with it a little bit better.

14:27This is especially important when you're working with geoprocessing services.

14:32Does that answer your question? Okay, cool.

14:35Okay, brilliant. Why did we bother to show you the local server and the local services?

14:41We actually thought you might be interested; it's kind of quite different kind of architecture.

14:45We thought that you might be interested in how it works in the background...

14:48...and it really helps you think about how you design your application.

14:51What are you going to do? You now know that there's a local server spinning up and some services.

14:56You know that there's a little bit of a time delay, 'cause they are going to take time to spin up.

15:00So you could just think about how you build your apps and show your customers...

15:03...to kind of make sure you've got something that looks good.

15:08Okay. Alright, let's go on and talk about analysis then.

15:14So analysis. You have data in your application, and you just want to maybe identify on it...

15:19...or query it or perform some geocoding, and this is all done very easily using a task framework.

15:25So it's basically the same programming model for all of these different kinds of operations.

15:30So we're not talking about geoprocessing at the moment; we're talking about straightforward analysis of the map or the layer.

15:37Okay. So task framework, there's a task package for this, so com.esri.tasks.

15:44Take a look in there and you can see these different types of tasks and explore the API and have a look at them.

15:49They very much function in a very similar way.

15:52They're subtly different because maybe one takes a layer, one takes a map, one just takes a geoprocessing, a geocoding package.

15:59So just take a look at that.

16:01I mean, basically you define the inputs, you're going to execute the task that's going to run, whether it's identify, query, geocode.

16:08Either you can execute them straight away or asynchronously.

16:12Depends how long you think that the application's going to take.

16:15Depends if your workflow requires an instant response or you need to wait for the information.

16:22Okay, and then when you get the results back, you need to process them and display them on-screen.

16:27So what kind of tasks have we got?

16:29We've got an identify. You're going to get the attributes of specific features that you're going to click on...

16:35...and for that, you're going to be clicking on the map.

16:38And the identify task, it needs to take the URL to a dynamic map service layer, so that can be an online layer or a local layer.

16:45So this is where we're looking at the API. This API works for online and local.

16:50There's not a separate API for online and a separate one for local; it's just one API that utilizes.

16:55You just need to provide the URL.

16:58So query. Asking a question about one of the layers, so obviously, you're going to provide the layer.

17:03And there's a WHERE clause, and now that is...

17:05Like, so you could have a spatial query or a WHERE clause to specify an attribute query.

17:12Again, the query task takes a URL to the layer, an online or local layer.

17:17Story's getting very familiar, isn't it? So it's just a familiar, constant working pattern for all of these tasks.

17:24Address to location and location to address, geocode, reverse geocode, whatever you want to call it.

17:29Basically, you're providing a URL to the geocoding service, local or online.

17:37Okay. Ralf's going to give us a demo of how some of these things work.

17:44Okay. Back on Ubuntu. So let's just run this app.

17:48I'm going to show you a geocoding application.

17:53Geocoding application is spinning up a local geocoding service.

17:57When I click Find on the address, I get back a graphic as a result, and I put that graphic in my map.

18:05That's really all I'm doing in this application.

18:08So let's look at the code. Here we are starting up a local geocoding service.

18:14We are starting it asynchronously.

18:17So this local geocoding service actually starts really quickly...

18:21...so we're not actually listening to when it's finished starting up, which is probably a bad coding practice.

18:26We should really listen to when it starts up and check to see if it started up correctly...

18:30...and once it's started up, then we'll continue with our code.

18:34So my bad for showing you bad code. I'm sorry.

18:37Once I actually have my geocoding service, I can then click the Find button.

18:46And the Find button populates this map, which is my address fields.

18:54Populates the map, which are the address fields, which I'm going to then pass into the locator.

19:00We'll call this locate method.

19:01The locate method up here actually creates a new locator, which takes the URL of the local geoprocessing service.

19:10This could be an online one; the locator class works both with online and local data.

19:16And then it calls the addressToLocationsAsync, which is an asynchronous call so you're not blocked...

19:22...as it sends it off to either the online service or the local service to get back on the callback.

19:31Get the result, which then we can parse, and we can populate...

19:37Here we've got the graphic, and we get the actual geometry of the graphic to create a graphic...

19:43...to put in the graphics layer on the map.

19:46And then those address results we put in that other JDialog that we show.

19:53And my mouse is clicking, and I must've copied and pasted code by accident without looking at it, so my app no longer...

20:01What did I do here?

20:03Well, you saw the app run before; I don't have to show it again.

20:06Let's go to the query. Let's run this query application.

20:09It's the same concept, so all these tasks have synchronous calls and asynchronous calls.

20:15We always say you should use the asynchronous calls when you're working with online data, even with local data...

20:20...but there's situations - maybe you're building a console application or something like that...

20:23...where an asynchronous call doesn't make any sense.

20:26Or you're highly dependent on a specific piece of data, you're going to want to make a synchronous call.

20:32But in general, you should be making asynchronous calls.

20:35So here, this application did two queries.

20:37It did one query to get all the states, so now we have this combo box with all the states listed in it from our service...

20:47...and then another task every time I select on a state to actually get back that geometry and zoom to that location.

20:54Let's look at the code real quick.

20:58So here is the code that we're populating that list of states.

21:02We're creating a query object, and then we're setting what we want to get back from the query.

21:09Then we execute...actually, like, we're executing this asynchronously; I lied.

21:14We're executing it asynchronously on the callback.

21:17We get graphics back as a result from the service, and then we go ahead and add those items to our combo box.

21:28Up here is actually where we're calling it synchronously. Right here. Somewhere here.

21:41Where are you? Execute. There.

21:44So we're creating a query task...there. I can't navigate my own code.

21:54We're creating a query task and then we're calling execute, passing in our query...

21:58...and you could specify if you want to get geometries back or not from the query.

22:01And every map service has this, so when I create an MPK, there's data behind that MPK.

22:07When I spin up a map service, that map service has the query functionality enabled on it...

22:14...so I can submit query tasks to it or identify tasks to it and I can do that synchronously or asynchronously.

22:21The same as a dynamic map service that I would publish in ArcGIS Server.

22:26Where there you would actually enable and disable functionalities, the Runtime, when it spins up a local service...

22:32...all the capabilities that Server has are already enabled on it. Does that make sense?

22:41Thank you very much. So Ralf just showed us geocoding and querying, so thanks, Ralf.

22:48Right, so that was the task framework, and that's a good area to get to know because you might think, okay...

22:54...I need to do all this processing down in geoprocessing, and actually you could probably do some of it with the task API already.

23:01So make sure you know that API, you know the functionality of that part of tasks before you head off into the world of geoprocessing.

23:10Right. But what is geoprocessing? Here we go, let's head off into this world.

23:17So geoprocessing. You know that you can enrich all your applications, ArcGIS applications, with geoprocessing.

23:24So what is it? It's a set of tools included in the ArcGIS system to perform GIS analysis.

23:30But don't just perform GIS analysis; you can do some other things with these tools.

23:34But there's a whole toolset, and it is vast.

23:38Some of those tools are not supported by the Runtime.

23:40So if you want to work out exactly which ones are supported by the Runtime today, you need to log on to the online help...

23:46...and have a look at, in the prerelease documentation, there's a list of supported tools.

23:51So please go and have a look in that, because if you've got some complex functionality...

23:55I know some people here already have some Engine applications that already utilize geoprocessing.

23:59Go and check out that toolbox; see if the tools that you need to perform are covered in that toolbox...

24:06...'cause if they are, there is a possible migration strategy for you to go from Engine to the Runtime.

24:12Now, we don't necessarily recommend that, because Engine is a great product, and you can do lots of functionality with Engine.

24:19You know, you've got the whole of ArcObjects at your fingertips to program against.

24:23But this is a smaller, lighter-weight deployment.

24:25It is possible, if you're just displaying map functionality or some simple geoprocessing functionality...

24:31...you could do that with this product.

24:33So if you're thinking about those design decisions, then just - it's that list of geoprocessing tools that's the crunch point for you.

24:41Okay. So system tools, some of them, yeah, support it.

24:47Then there are custom scripts. You can write your own custom scripts for that...

24:51...using Python, so therefore you'd need to make sure you deployed the Python module in your deployment.

24:56Otherwise, you'll write them and then it won't run, so make sure you do that.

25:02Okay. So using geoprocessing in the Runtime.

25:07So your API, you have an API.

25:09Currently now, you can perform some geometry functionality, you can perform these various task operations...

25:16...but maybe you need more than that and that's where you're looking at geoprocessing.

25:21So geoprocessing services are published online. You can get access to them.

25:27One of the samples is a very famous sample which we utilize all the time, which is the Message in a Bottle sample.

25:34And in that, you basically...it's an online service.

25:37It's a straightforward online service, and you can utilize that in your application...

25:42...or you could package up any service and produce a geoprocessing package, and then we can utilize that within our API.

25:52So the options are an online service or a local geoprocessing service.

25:56With a local geoprocessing service, you're starting up with a geoprocessing package.

26:03Okay. So to utilize the programming model, the only difference between those two models...

26:12It's a bit like the task framework earlier. Geoprocessing is really, does fall into that same kind of task framework.

26:19The only difference between online and local is that for local, you need to prepare the URL for the geoprocessing service.

26:26So you'd start up the local geoprocessing service, point it to the geoprocessing package...

26:30...and that would return you a URL to the geoprocessing service.

26:34From that point onwards, all the code's the same for online and local.

26:39So you would create a geoprocessor; provide the URL to it, either online or local; and then provide the right...

26:45...input parameters for the tools that you're going to run; and then either execute it or submit it.

26:51So we'll talk a little bit more about that a bit later.

26:55So the parameters. There are lots of input and output parameters for geoprocessing, and they're all documented...

27:00...so I'm not going to bore you with a nice big list of all those parameters, but you can go online and just check out those parameters.

27:07There's only a few that are not supported. So go and have a look at those.

27:11One of the really important ones I've picked out is the GPFeatureRecordSetLayer.

27:16Now this is a very important, this is a very important parameter type, 'cause if you want to get features into your model...

27:23...or back out of your model, you need to know how this layer works.

27:27So it supports points, lines, polygons; has a spatial reference; you have attributes as well.

27:33So it's important to get familiar with that type of data.

27:38And you can either, you can populate it from the client side with a feature layer or a graphics layer.

27:44Okay. Packaging geoprocessing. So we're going to do a geoprocessing package demo?

27:54I wasn't planning on it.

27:55Not planning on it. That's alright. When you package a model for geoprocessing, you would run the analyzer.

28:02You saw the analyzer already when Ralf was creating a package with tiles and map packages.

28:09So it's the same kind of analyzer that's running; it's going to analyze the model, analyze the inputs, and it does a lot of work...

28:15...to work out whether that package you're creating is appropriate, whether the appropriate tools are supported.

28:21So if you don't check the tool list, if you went to package it, the analyzer would tell you...

28:27...This tool's not supported. This data type's not supported.

28:30So you would get some good results on there, and it also tells you whether you need a particular type of deployment.

28:36So you see this Select Data tool, it requires standard; it's a standard geoprocessing deployment.

28:42Okay? And in fact, they're all standard.

28:44If this geoprocessing package was performing some very special kind of spatial analysis, it would tell you...

28:50...This requires the ArcGIS Runtime spatial analysis extension.

28:56So basically, most of the geoprocessing just requires a Standard license if it's for local geoprocessing. Okay.

29:07Okay. And Ralf, if you're ready, he's going to give us a demo of geoprocessing.

29:18Okay, so I actually decided, which might be a bad idea, if I can get the display, to kind of change the demo on the fly.

29:27So I'll apologize for anything that goes wrong.

29:30And I'll show a quick packaging demo too...

29:33That would be great.

29:34...that I totally threw together right now.

29:36Okay. So here I just want...here I've got a geoprocessing demo. I'm doing a viewshed analysis.

29:44I've consumed a geoprocessing package that I've created in ArcGIS Desktop; this is on my Ubuntu box.

29:52I am here - where did I put the code - right here, I am actually creating a local geoprocessing service...

30:03...and pointing it to my geoprocessing package that I created.

30:07I'm setting the service type to SubmitJobWithMapServerResult because the output of this geoprocessing service is a raster...

30:13...and I want to display it as a local map service in my map.

30:17I'm wiring in - because remember, this is an asynchronous API - the addLocalServiceStartCompleteListener...

30:26...so when the local service is done starting up, I know, 'cause this event fires.

30:31I'm being smart and I'm showing you good coding practices.

30:35I am checking to see if the local service actually successfully started up before I enable my Solve button on my demo.

30:44If it doesn't, I'm just going to print that it failed.

30:48So the actual app I already started running, and it's the one you saw earlier, the viewshed app.

30:56This is a tile package of Yosemite.

30:59When I click on the Solve button, which is only enabled because the service started up...

31:03...I click somewhere on the map, it starts processing.

31:07While it's processing, which shouldn't take too long but let's just go ahead and look back at Eclipse...

31:13...what happens when I'm clicking this button?

31:17There's my Solve button and down here is where I'm actually submitting it.

31:23So I've created a graphic, I created the geoprocessor.

31:27I'm getting the URL from the geoprocessing service, and I'll show you that in a second.

31:31I'm creating my geoprocessing parameters list; I'm creating a GPFeatureRecordSetLayer...

31:38...which is how I get my graphics from my app into the geoprocessor, telling it what geometry it is...

31:45...actually adding the graphic, then adding that GPFeatureRecordSetLayer to my parameters...

31:52...and then submitting the job to the geoprocessing service; listening to that callback.

31:57When it's done, I get an ArcGIS dynamic map service layer.

32:02I set it to slightly transparent and then I just add it to my map.

32:07So by now, this guy's done and here's my viewshed result in my map.

32:15How do I figure out what these parameters are?

32:18Well, what I can do is after - remember, we saw earlier when we spun up the local server, we got that URL.

32:24I can take that URL and I can paste it into a browser and I can check out my geoprocessing service...

32:31...and I could see what the parameters are for it.

32:34And if I want to get more info, I could look at the JSON for it, and I could see that it needs a point...

32:40...that the actual GPFeatureRecordSetLayer name is - I'm not good at reading JSON; I'm going back here, because that's easy...

32:50...it's Input_Points, Input underscore Points.

32:53So when I'm creating this input, I give it, the GPFeatureRecordSetLayer, I give it the name Input_Points.

33:07So now it knows that this GPFeatureRecordSetLayer maps to that parameter.

33:11And the result, which is called Result, is what I'm getting back as a raster.

33:19So let me pop over to the Windows machine for the on-the-fly packaging of the geoprocessing package demo.

33:31Okay. So here is actually the DEM that I used for Yosemite to create this geoprocessing package.

33:40And I'm not going to build the package from scratch 'cause that would take - where'd my model go? Here we are.

33:46The model, from scratch, that would take way too long.

33:49But the key things are GPFeatureRecordSetLayer. What is that? These are the Input_Points, which I've marked as a parameter.

33:55If I right-click on that and I hit Properties, I go to Data Type, I set it to a feature set.

34:01Then I give it a feature class that's its schema, and that's it really.

34:08And then I've got my output parameter and my model does whatever it does. (Don't save changes.)

34:14So when I run the model, this guy, when I run my model, I click on my map, because I'm using a feature record set...

34:33...I run the model, the model executes, then, out of my Results window...so there's my viewshed result.

34:46In my Results window, I right-click on this guy, Share As > Geoprocessing Package...

34:51...enable Runtime support, hit the Analyze button - remember the analyzers; they're super important...

35:00...then I get information that tells me, hey, you're using a tool that requires a Runtime Standard license.

35:08Hey, you are using a tool that requires a Runtime Spatial Analyst license.

35:13If I was using tools in there that aren't supported in the Runtime, it would say no, you can't use that tool in the Runtime.

35:18We don't have that functionality.

35:20So the analyzers are really important.

35:22It would also tell me if I have something in my model that requires an additional deployment.

35:29So then when I'm ultimately creating my deployment, which we saw earlier in my deployment tool...

35:39...I would use those analyzer messages to know that, oh, I need Spatial Analyst to do this or I need 3D Analyst to do this...

35:50...in addition to my geoprocessing requirement.

35:57Make sense? Cool? On the fly. Back to Mary.

36:00Perfect. And another question on the fly for Ralf is - do you like on-the-fly questions? Excellent. Okay.

36:08What if a gentleman over there gives you a geoprocessing package that you need to write some code against?

36:14What are you going to do? It's just a package; you don't know what's in it.

36:16What could you do to find out what's in it?

36:18I'd probably do two things. One, I could open it up in ArcMap and run the analyzers against that geoprocessing package...

36:26...that he gave me to make sure I can even run it in the Runtime in the first place.

36:30The other thing I can do is I can actually take that geoprocessing package, spin it up in the Runtime...

36:36...grab that URL, and explore what I got so now I know how to work with this package.

36:42Like we saw earlier over here, I spun up the geoprocessing service, pasted the URL in a browser.

36:51Now I can look at the geoprocessing service, see what kind of parameters they are so I know how to work with it...

36:57...when I create my geoprocessor, and I create my parameters to ultimately execute my geoprocessing task.

37:04So geoprocessing is a really important area.

37:07This is the bit that really enriches your applications is with GIS functionality...

37:11...so it's really important that you are kind of familiar and you understand how this is going to work.

37:18No more ad hoc questions from me then, huh? Sorry about that. It's okay.

37:24Okay, let's go ahead and talk about editing then. Right. Okay, editing with the ArcGIS Runtime.

37:33Going to talk later about synchronized framework, but right now...

37:36...we're just going to talk about functionality for editing that's like in the box at the moment. Okay.

37:42So editing with the ArcGIS Runtime is basically supported through the feature service.

37:48You saw the feature service is one of the services that we support, so for both online and local editing...

37:53...it all happens through the feature service. Okay.

37:58And the SDK, when you install it, you've got a toolkit for editing, there's some samples...

38:04...and there's quite a few API components that'll help you through the editing process.

38:09And this editing environment is basically authored through Desktop.

38:12Whether it's for an online service or in the map package, you need to author that editing environment. Okay.

38:21So what would your editing workflows be?

38:24You are going to build a client API with whatever toolkits or whatever code you're going to have...

38:30...and you can operate with ArcGIS Server or you can operate with ArcGIS local server, either of them.

38:36So the workflow for doing this work is in ArcMap you want to, basically you're going to utilize a file geodatabase...

38:48...some data that you want to edit, and look at designing the feature template.

38:53Look at setting up the right cartography, the right way of working with the editing the data.

38:59So set up the symbology that you want to work with.

39:01Maybe there are certain types of attributes that you allow people to edit.

39:05Maybe you've got coded value domains that you want people to work with and only set the data according to those.

39:11So there's lots of parameters you can set in ArcMap on that data, on that online data, before you publish the service.

39:20So once you've designed that, you can publish it online or publish it to a map package.

39:25But basically, you're really setting up your editing environment by setting up those feature templates.

39:29And once you've done that, if it's online, you can publish it as feature service...

39:35...and you can acquire the URL and basically edit in the Runtime.

39:40It's the same process for local feature service as well.

39:44You need to design your editing environment, the symbology, the things that you can edit...

39:49...the coded value domains, absolutely same setup.

39:52You do all of that in ArcMap and you go to publish, and you're sharing it as a map package.

39:56So all of that information about the editing process is stored in the map package...

40:03...and when you supply that map package to a feature service...

40:07...you can then go through the editing process with the same UI components that we're going to show you.

40:15Okay, so you've got quite a few options for all the different kinds of editing you could do.

40:20One of them is perhaps to have a really nice synchronization framework.

40:25We don't have that at present, but we're working on that right now for a future release.

40:29So at the moment, these are kind of like the editing options that you could work with.

40:34So first off, you could create a map package and embed your file geodatabase completely within that map package.

40:42If you go and edit that with a feature service, with a local feature service, those edits are retained locally in that file geodatabase.

40:51When you create the map service and point at the map package, it's going to unpack it somewhere...

40:56...so actually you can find out where that is, but it's almost like to a secret location in your machine.

41:00That's the unpack location.

41:02When you make an edit, it's made into that file geodatabase in that location.

41:07That's sort of a temporary edit process.

41:10I mean, the edits are permanent, but because it's in a file geodatabase in the unpacked location...

41:15...it's not easy for you to get at that file geodatabase and utilize.

41:18So basically if you include the file geodatabase inside the map package, that's what we think of like a temporary edit process.

41:26If you want your edits to be more permanent, when you create the map package, I don't know if you remember...

41:31...on the options, one of them is to reference the external data.

41:35So if you reference it externally, you have a map package and you'll have a file geodatabase held externally.

41:43So when you make your edit through the feature service, it'll update the file geodatabase...

41:49...and you'll know exactly where it is, 'cause you're referencing it directly from the map package.

41:53So you could then forward that, e-mail it to somebody else, or return it to some GIS analyst...

42:00...and they might be able to sort of incorporate those edits back into some corporate database.

42:05So that would be for like a remote editing situation.

42:10Okay, you could make permanent edits to a relational database management system, RDBMS.

42:20Okay, so again, your map package would reference that RDBMS, okay?

42:24Same situation; you make those edits and it's editing on an RDBMS.

42:30Okay. Or you could make those edits through an online service, so an online feature service.

42:35So you've got a lot of options, and it really depends on the business process that you're working with.

42:41As I said, the sync framework will not be at release 1 but it will be soon afterwards.

42:47Okay, so authoring maps for editing.

42:50I don't really want to go through all the detail on this, but basically, make sure that you design your maps well...

42:55...your editing environment well in ArcMap.

42:59That's the important place for you to get all of that information set up.

43:05Okay, the SDK. If you go and look in the toolkit, there's a section in there just for editing...

43:11...and there's lots of different things you can work within there and have a look at the samples.

43:15There's a template picker that's going to utilize the feature templates that you've already designed in ArcGIS for Desktop.

43:21Have a look in there and there's a sample for template picker, and if you look in the code behind that, you can see how that works.

43:29Okay. As I said before, anything in the toolkit you've got access to all of the code as well...

43:35...so you can really work [sic] at how it all works.

43:38Okay, Ralf's going to give us a quick look at some of the toolkit things and show us the - we've got an editing demo, trails demo.

43:48Yeah. So Mary just talked about the template picker, which is actually coming from the toolkit.

43:55This sample is pointing to online feature services.

43:59It's actually an online tiled map service and two online feature layers that, if you've been to any of the other web API demos...

44:10...they're probably using this because I can see when I log on to this, or when I use this feature service...

44:14...there's tons more edits than I last remember when I was on it.

44:19But the key here is somebody made this map service and enabled it as a feature service so that I could edit it.

44:27They went into ArcMap and they used feature templates, feature templates which were introduced at ArcGIS 10...

44:33...where you define your symbol and then you define default attributes for particular features that people are going to edit.

44:43So a user could just click on a symbol; attributes are already defined.

44:47They create the feature, it populates the table. Easy and good.

44:53We in the Runtime, through all the web APIs also, can actually read those feature templates from the feature service.

45:02So all that work to make this cool cartography, this cool symbology, and all this attribute information didn't go to waste...

45:09...because you can consume it elsewhere.

45:12The JTemplatePicker is just a toolkit example that shows you how to do it.

45:17So if I want to edit an online service and I want to create a fire department...

45:22...I can just click on the map and create a fire department.

45:26I can then if, whoever defined these attributes for those - actually, this symbol's probably defined...

45:31...I mean, it is defined by an attribute, so that attribute is already populated into the database.

45:36So this is just the toolkit that you can use. You can also build your own custom editing app...

45:42...and you saw it in the first session on Ubuntu, and actually I wrote in on Windows and I dumped it onto Ubuntu...

45:49...and it worked, which is cool about Java, I guess. It's not really, but alright, yeah, it's just Java that does that but...

45:57So what this sample is doing, which let me run it.

46:06So it starts up, this is a tile package; the basemap is a tile package...

46:14...and then the trails that you see here is actually a feature service.

46:19When I click on this Start Editing button, going into the feature service, I'm pulling out the graphic, the symbol...

46:27...from the feature service, and I'm just populating these JButtons.

46:30I actually have two feature services here; one's a point, the other one's lines.

46:34And I grabbed the actual feature templates from the feature service and I put them on a button...

46:39...so I could build my own custom editing application.

46:43So if we look at the code here, I'm actually using the toolkit to do this.

46:47I'm using the prototype builder from the toolkit...

46:49...'cause I don't want to have to write all the code myself to actually get the feature templates.

46:53It's not too hard, but we already did it for you with the prototype builder.

46:57So I just get the prototype builder and then I go and get the icon from the prototype builder and then I...

47:04...stick it on my button, and that's really all the code that I did to create that button with the image from my feature service.

47:11Then, as I go in and I edit - uh-oh - as I edit, I can go ahead and create a trail here.

47:23Yeah, that looks good. I like - Oh! I created two trails.

47:29I can go ahead and I want to get there with a parking lot, maybe there's some problem along the way...

47:35...but over here there's a really cool historic site and you want to get maybe to the viewpoint to see it - oh!

47:42The viewpoint...the viewpoint...the bad coder.

47:49To see a bunch of historic sites.

47:53So the point here is I've been editing a local file geodatabase, and in fact, I have the local file geodatabase right here...

48:04...and as I pan around, you see my edits that I just made.

48:07If I go ahead and make another parking lot, maybe a campsite - not going to do another historic site...

48:16...and put that - it's a picnic table - over here, I go back to ArcMap and I hit refresh, those features are in there...

48:22...because I'm looking at that same local file geodatabase and I'm editing it directly with the Runtime application.

48:31Wow. Okay, that's good.

48:34So there are lots of tools, basically there's lots of toolkit elements - what did we learn from that?

48:38Lots of toolkit elements and just you can build a lot of different types of editing applications.

48:43And make sure that somebody tests it before you can...that was the most important thing we learned. Okay.

48:49Especially editing applications where you've got to change data, yeah, sure. Okay.

48:54Right. So we've been through, had a good look at the service, we've had a good look at analysis, geocoding...

49:02...sorry, geoprocessing, and now editing, so that's kind of most of the functionality.

49:08So now I just want to go back and just have a little think about this licensing for deployment. Okay.

49:15So, there are three levels, and one of them I discovered today was Basic includes military message processing...

49:22...for those people that are interested in military message processing.

49:25So with a Basic license, you've got access to the full ArcGIS services online.

49:33So you can access any of those, edit, do whatever you like with those services.

49:37You can also load up local tile packages with this Basic license, and there's GPS support.

49:43There's actually quite a lot of support, which I haven't listed on here.

49:48And maybe the main thing, really, is that Standard license is required if you need to spin up this server.

49:54If you need to utilize the server and the services, that would require a Standard license.

49:59I'm putting this up here and this guy's taking a photo.

50:02This may change, but this is the current situation, just so you know when you take the photo.

50:09So when you're spinning up your local map, local map services, using any local services, you need a Standard license.

50:16Routing as well.

50:19So for extensions, and this is very specialist geoprocessing functionality, so some of these...

50:27...some 3D Analyst, some geo - network analysis functionality, do you know which ones are included in Standard?

50:33I just can't remember off the top of my head.

50:36Simple point to point routing is included with Standard, viewshed is included with Standard.

50:43So it is really very specialist things that are part of the extensions really.

50:51So in terms of price point, yes, I don't know the price points.

50:59I do know the price point for Basic actually. It is free.

51:02So Basic means free. It's not free really, because somebody has had to pay to implement the services.

51:09You know, somebody's had to pay somewhere along the line to get these services running...

51:14...to create the tile package, you know, had to have Desktop to create the...

51:17So somebody's paid something somewhere, but for you to utilize just that functionality...

51:22...you don't have to pay anything to put a Basic license in your code.

51:28And for Standard, there is slightly more of the extensions.

51:31We don't know what the price point is, but my understanding right now is it is a lot less than Engine...

51:37...and if you are a MapObjects person, you will be familiar with the pricing strategy.

51:44I actually can't - I don't know any more than that myself so...okay.

51:50So Basic, no additional cost. Notice I didn't say no cost; no additional.

51:54It's not additional because you already had to pay to build these things.

51:58Okay, so these Standard and extensions, they are sold in packs of 25; that is the plan at the moment.

52:05And we're at just prerelease, so presumably that plan might not change, but if it does, I'm sure you'll be told.

52:12No price book at the moment. (And I've just gone the wrong way...)

52:17There we go. So core benefits.

52:20This is a bit of a summarized slide, but it is trying to put in context of MapObjects and Engine.

52:26So if we just run through them, you can see that there is a simple object model, there is a simple object model.

52:31When we looked at the code for the GPS layer, it was simple and straightforward to follow.

52:36It is much more simple than some of the ArcObjects APIs that you've seen before.

52:42So hopefully, that is straightforward, and that is one of the main objectives of our development work...

52:46...is trying and simplify that down so it's easy for you to use.

52:50MapObjects kind of fell into that remit as well.

52:54Engine's got lots of functionality. I mean, there are lots and lots of interfaces and classes..

53:01...basically is a much more complex beast, but I have to say, it has a lot more functionality than this does at the moment.

53:10We have a very fast display.

53:11We spent a lot of time over the last few months trying to get this fast display into the Runtime products...

53:18...and it has caused a delay, which is why we're not produced prerelease at the same time as the Desktop prerelease.

53:24So I apologize for that, but we would not have been able to have a fast display.

53:29It was good, but it was not as fast.

53:33Very simple licensing model. You saw that all you have to do is acquire these packs of licenses.

53:39You actually use the software authorization wizard to put these licenses on your machine...

53:44...and you might want somebody in your company to do that. Not every developer has to do that.

53:49You might want somebody in your company to say, right, I'm going to acquire these packs of licenses.

53:53Here they are; that's the string. Okay.

53:55And this is based on an honesty system, okay? So you put that string in your application and you deploy that application.

54:03You've purchased the right to deploy that application 25 times, so you deploy it 25 times.

54:09If you deploy it 50,000 times, somebody will notice at some point in time.

54:14And that strategy for licensing may need to change.

54:18So basically, it's based on honesty, and if it gets abused a lot, unfortunately, we might have to put in some strategy for limiting that.

54:27I don't want to do that. It's going to make licensing a lot more complex, so let's try and be honest.

54:33Okay, so simple licensing model. It's the same with MapObjects; straightforward. Okay.

54:40Engine, you could do geodatabase editing, read, write, et cetera. You could not do that with MapObjects.

54:46You could not edit SDE databases with MapObjects.

54:50You can access ArcGIS Server services, support rasters, utilize geoprocessing, exactly the same as Engine.

54:58We do support good cartography, so all of the things that you would expect - labeling, nice Python style labeling, all supported.

55:08Side-by-side SDK and deployment. That is really, really critical for the success of this.

55:14So when you create your deployment, you saw that you licensed it, whatever, you put it in that deployment folder...

55:21...and that is what you deploy, and that deployment folder contains the code of your license string in...

55:27...it contains your runtime, and anything else you need.

55:29You just deploy that. So that's your single deployment.

55:33So very simple, and it means that you can have as many versions of the Runtime on a machine that you could possibly want.

55:41'Cause only one Runtime sits with one application.

55:46Just deploy what you need. That will make it as small as it possibly can be.

55:50If you just want to deploy the map, you just want to utilize the map, just deploy the components you require for producing a map.

55:58If you want to build an enormous app, check on all those boxes on the deployment tool and you can deploy whatever you like.

56:03So what your functionality, the size of your deployment is influenced by the range of functionality you want to deploy.

56:14Okay, so where do we sit in this range of ArcGIS products?

56:18So black, MapObjects is not sold anymore.

56:24So it fits between MapObjects and Engine.

56:27So Engine has more functionality; Desktop has even more, but it does cover quite a range of functionality.

56:35And this lozenge shape may change over time; it may get bigger.

56:40The bigger we make it, the bigger the deployment's going to be.

56:44So one of the reasons for focus, keeping this a very focused application.

56:48We're just focusing on geoprocessing, not opening up the whole ArcObjects model.

56:52If we did, the deployment would be enormous, so this is really our main focus...

56:56...to keep this small, lightweight, so you can deploy it easily. Okay.

57:04Alright, platforms. We've got a few machines here. I've got a 32-bit Windows, you've got a 64, we've got an Ubuntu.

57:11We've actually got a MacBook over there. We don't have a Red Hat or a SUSE machine.

57:17So at prerelease, we are going to support Windows 7, Linux Red Hat, Windows 32, 64. That's it, yes. That's it. There is no more.

57:30But at final, that will be a lot wider. Okay.

57:33I've put MacBook Pro on here. Why have I done that?

57:35Because we all know that if you want to develop in MacBook Pro, that's in Objective-C...

57:40...but you can run a Java application on a MacBook Pro.

57:43So we're just going to quickly show you that.

57:45Elise has got a - something silver box with an apple on the front. Over to you, Elise.

57:51[Inaudible audience question]

57:53Not for prerelease. We have some problems with the DirectX DLLs that we need to deploy.

57:58So we're trying to fix that problem with Microsoft. So I apologize; no XP for prerelease at present. I'm sorry.

58:06Okay. I'm just running the sample application that you've seen earlier.

58:10I'm dropping my microphone. Hello? Okay. Sorry about that.

58:16Okay, so let's just have a look at some samples here.

58:19We talked about the geoprocessing a lot today, so just going to show you that one here.

58:23Message in a Bottle...okay. Let's run this. Click a point. Now it's doing the processing.

58:32And I get the bottle path that if you were to somehow be off the coast of Brazil and drop a bottle in the ocean...

58:39...there's a good chance that it would end up about here a year later. So there we go.

58:43And just to drive the point home about services here, this is the information about the service that the sample is calling...

58:52...and so you see here that the parameters, we've got, oh, this is an input parameter.

58:58And that's the point, so that's the click point that I obtained when I drew a graphic at that point.

59:03I obtained that point using a map overlay, we draw that graphic, and then this is another input parameter is the amount of days.

59:10You get that from the text box, and then you get the output and you draw that on the application.

59:17So there we go, and that's running on MacBook Pro.

59:21Fantastic, so Java application.

59:23So that is not the SDK, although that was the sample application. It was.

59:28We built a special runnable JAR to run on that MacBook Pro, so that's...

59:36We're not sure if we're going to - we haven't fully tested that, just so you know, but that's just to give you some idea...

59:40...you can run, it's just a Java application at the end of the day. Okay. Thanks, Elise.

59:47Right, the road map. What are we doing?

59:50Prerelease available in April, I just haven't got a date on there.

59:54Hopefully it will be in April, hopefully before the end of April, maybe - I don't know what the date is today.

1:00:00Couple of weeks away, something like that.

1:00:03Okay, so if you - hands up. Who is using beta 2 of the Runtime? There's one gentleman over there at beta 2.

1:00:11Your licenses are going to expire on the 2nd of April, so if you need new licenses...

1:00:16...you need to go to the customer portal and download, ________ download the new licenses. Okay.

1:00:22And the final will be available in summer, so we need to release after ArcGIS 10.1 - 10.0 is released, sorry.

1:00:32Forgot which product we were coming; 10.0. We're in 10.1, sorry. Gosh, time flies.

1:00:41We need to release after 10.1, okay? Because the packages that you generate from Desktop can be utilized in the Runtime...

1:00:48...so therefore, we can't release before they do; otherwise, you'll have no packages that you can build.

1:00:53So we have to wait for them to release.

1:00:55And then after that point in time, we're intending to be off cycle, maybe a three- or four-month turnaround with releases.

1:01:01So it'll be 1.0 in the summertime, and it'll be 1.1 a few months later.

1:01:08So once we've got that release after Desktop, we're free to kind of release and update as fast as we can.

1:01:15So that is very important for us, it's very important for us if you can give us feedback...

1:01:22...on what you think our functionality should be what direction we should go in, what should we focus on.

1:01:28Basically, any feedback you can give us is very useful, because we need to be fast and rapid in terms of turning around functionality.

1:01:36[Inaudible audience question]

1:01:47In your application?

1:01:51Well, yes, 'cause the geo...if you're going to be messing, which I don't recommend you do that, but you could do that technically.

1:02:03If you're going to be messing with the geodatabase, so it's going to be a 10.1 geodatabase.

1:02:07[Inaudible audience question]

1:02:18Okay, I've just got one more slide. Then you can ask lots of questions. Okay, alright, let's just do this quick.

1:02:23So you noticed that there was no synchronization framework. That is true for all of the Runtime products...

1:02:28...so that's probably the most important thing that we're working on right now is trying to get that working...

1:02:33...so that we can release that after the 1.0 [sic] release.

1:02:37A lot of people have requested the need for printing and exporting that map, so that's another thing we're going to work on.

1:02:45Few customers, some important customers are really interested in 3D.

1:02:51So does anybody here have 3D Engine applications? You do?

1:02:56What kind of industries are you, just roughly? Defense? Defense.

1:03:02I know there is some oil industry people as well quite interested in 3D; mining, et cetera.

1:03:07So there are some people that are really interested in 3D, so we're going to be looking at that soon.

1:03:13Some defense people are interested in Image Server, I know.

1:03:17But really, I honestly have never seen so many Java people in a room all together...

1:03:21...so if you can come and tell us at the end what you're interested in, I would be really, really pleased to know.

1:03:28JavaFX. Hey. So you noticed they're all Swing components.

1:03:33Does anybody develop in JavaFX at the moment? One guy over there.

1:03:38So he's going to come and tell me all about his experience, and why he doesn't like Swing, so that would be good.

1:03:43So that's a future project for us, you know, it's on our cards; we know that this is possibly a direction we need to go in...

1:03:52...but we kind of need you guys out there to tell us so that we can make sure we're going the right direction for you.

1:03:58'Cause this really is not built for anybody else but you.

1:04:02What about SWT? Does anybody...

1:04:05[Inaudible] Yeah? [Audience comment] Absolutely.

1:04:09And JavaFX, there's only one person raised their hand, but is anybody thinking about JavaFX? No, just one person.

1:04:15There's a guy almost put his hand up over there. Interesting. So those are the things we need to know.

1:04:22If you're not interested in JavaFX, then we'll use our resources somewhere else. So that's interesting to know.

1:04:30Okay. There, that really was my last slide so that really opens up the floor for any questions at all about anything.

1:04:38And before you start the questions, there is a survey.