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.
Building Applications with ArcGIS Runtime SDK for Java—Part II
Mary Harvey, Ralf Gottschalk, and Elise Acheson explore application design, mapping, editing, analysis, and geoprocessing of ArcGIS Runtime SDK for Java.
- Recorded: Mar 28th, 2012
- Runtime: 1:04:59
- Views: 870
- Published: Apr 23rd, 2012
- Night Mode (Off)Automatically dim the web site while the video is playing. A few seconds after you start watching the video and stop moving your mouse, your screen will dim. You can auto save this option if you login.
- HTML5 Video (Off) Play videos using HTML5 Video instead of flash. A modern web browser is required to view videos using HTML5.