Code Your Own: Tool Integration using the Basic Learning Tools Interoperability (LTI) Standard
Download as PPTX, PDF9 likes6,921 views
The document provides an overview of coding a tool integration using the Basic Learning Tools Interoperability (LTI) standard, particularly in the context of Blackboard Learn. It explains key concepts such as tool providers and consumers, basic LTI permissions, and demonstrates how to use the LTI mechanism within Blackboard building blocks. The content also includes practical examples using a Java library called blti-sandwich to facilitate LTI implementation.
![/** * Performs the Basic LTI launch using blti-sandwich. */@RequestMapping("/blti/tool")publicStringlaunch(HttpServletRequestrequest){// Parse out the BLTI launchBLTIMessagemsg=BLTIProvider.getMessage(request);// Load the consumer that matches the key passed in the launchConsumerconsumer=consumerDAO.get(Consumer.generateKey(msg.getKey()));// Validate the message (make sure the message was signed by the shared secret)if(consumer==null||!BLTIProvider.isValid(msg,consumer.getSharedSecret())){returnerrorRedirect(msg,"Error: Not Authorized!");}// [More validation edited out here...]else{// Provision a user objectprovisionUser(msg,consumer);// Set up the HTTP session for the userHttpSessionsession=request.getSession(false);if(session!=null){session.invalidate();}session=request.getSession();// Keep the BLTI message in session for use in other pages.session.setAttribute("bltiSessionMsg",msg);// Redirect to the tool (Poll) display pagereturn"redirect:/blti/tool/index";}}](https://image.slidesharecdn.com/codeyourownltitoolprovider-110718121633-phpapp01/85/Code-Your-Own-Tool-Integration-using-the-Basic-Learning-Tools-Interoperability-LTI-Standard-27-320.jpg)
Code Your Own: Tool Integration using the Basic Learning Tools Interoperability (LTI) Standard
- 1. Code Your Own Tool Integration Using the Basic Learning Tools Interoperability (LTI) Standard#blticodeJim Riecken & Dan RinzelBlackboard Learn Product Development
- 2. BasicLearningToolsInteroperabilitywith Blackboard Learn™, Release 9.1 SP4
- 3. Q’s we will try to AWhat is LTI?What is Basic LTI?What does being a Tool Provider mean?What does being a Tool Consumer mean?What does that look like in Learn?What does it look like for Blackboard Building Blocks?Hungry yet? Code your own Tool Provider
- 4. What is LTI?“a single framework or standard way of integrating rich learning applications...to allow the seamless connection of web-based, externally hosted applications and content…to platforms that present them to users”http://www.imsglobal.org/toolsinteroperability2.cfm
- 5. What is Basic LTI?Simplify, Simplify, Simplifyone launch mechanism with one security policyno access to run-time services on the platform
- 6. What’s a Tool Provider?A (typically centrally hosted) service that interacts with users who are “launched” from inside their platformLaunch mechanism and authN as specified, including extra data in the launch “payload”
- 7. What’s a Tool Consumer?A LMS, VLE or portal environmentSets policy about the payload privacy, who can provision links
- 8. What does that look like in Blackboard Learn?
- 9. Basic LTI & Blackboard Building Blocks™
- 10. Why use a Blackboard Building Block?More seamless integrationTool placementContent Handler placementBypass global provider settingsPermissions declared in bb-manifest.xmlInstructors don’t need to deal with URLs, Keys, and SecretsThey might not even know that the tool is running on another server!
- 11. How to use Basic LTI in a Blackboard Building BlockTwo PartsDeclare permissions in bb-manifest.xmlUse blackboard.platform.blti.BasicLTILauncherIn your Tool page or Content Handler view page
- 12. Basic LTI PermissionsNew “basiclti” permission type.Name is the domain you intent to launch to.Use “*” if you want to launch to any domainSpecifying a domain allows subdomains as wellValue is some combination of“sendroles” – Allow user’s role to be sent.“sendname” – Allow user’s full name to be sent.“sendemail” – Allow user’s email address to be sent.If the value is empty, you will just be able to launch to that domain.
- 13. Basic LTI PermissionsExample<permission type="basiclti" name="example.com" actions="" /><permission type="basiclti" name="foo.example.com" actions="sendroles" /><permission type="basiclti" name="bar.example.com" actions="sendname,sendemail" /><permission type="basiclti" name="baz.example.com" actions="sendemail" />
- 14. BasicLTILauncherEncapsulates the logic for performing a Basic LTI launch.blackboard.platform.blti.BasicLTILauncherblackboard.platform.blti.BasicLTIConstantsSimple APICan add user/course informationCan add custom parametersDoes OAuth signing and redirects to an automatic launch page.
- 15. BasicLTILauncherConstructorBasicLTILauncher(String url, String key, String secret, String resourceLinkId)Data Population (all return BasicLTILauncher)addResourceLinkInformation(String title, String description)addCurrentUserInformation(booleanincludeRoles, booleanincludeName, booleanincludeEmail)addUserInformation(User user, CourseMembership membership, booleanincludeRoles, booleanincludeName, booleanincludeEmail)addCurrentCourseInformation()addCourseInformation(Course course)addLaunchPresentationInformation(Map<String,String> params)addCustomToolParameters(Map<String,String> params)LaunchMap<String,String> prepareParameters()void launch(HttpServletRequestreq, HttpServletResponse res, booleanuseSplashScreen, FormattedTextsplashScreenMessage)
- 16. BasicLTILauncher - ExamplesSimple LaunchBasicLTILauncherlauncher=newBasicLTILauncher("http://url.to.my.tool","my.key","s3cr3t","resourceId_1");launcher.launch(req,res,false,null);Launch with current user and current course (from Context) and a splash messageBasicLTILauncherlauncher=newBasicLTILauncher("http://url.to.my.tool","my.key","s3cr3t","resourceId_1")//Send roles and name, but not email.addCurrentUserInformation(true,true,false) .addCurrentCourseInformation();launcher.launch(req,res,true,newFormattedText("You are launching my tool. Click Submit.",FormattedText.Type.PLAIN_TEXT));
- 17. BasicLTILauncher - ExamplesThe kitchen sinkUseruser=...;// Get user somehowCoursecourse=...;// Get course somehowCourseMembershipmembership=...;// Get user membership in courseMap<String,String>launchPresentation=newHashMap<String,String>();launchPresentation.put(BasicLTIConstants.PARAM_LAUNCH_PRESENTATION_DOCUMENT_TARGET,BasicLTIConstants.PARAM_LAUNCH_PRESENTATION_TARGET_WINDOW);launchPresentation.put(BasicLTIConstants.PARAM_LAUNCH_PRESENTATION_RETURN_URL,PlugInUtil.getUri("vendor","handle","/path/to/my/return"));Map<String,String>customParams=newHashMap<String,String>();customParams.put("param1","value1");customParams.put("param2","value2");BasicLTILauncherlauncher=newBasicLTILauncher("http://url.to.my.tool","my.key","s3cr3t","resourceId_1").addResourceLinkInformation("resourceTitle","resourceDescription").addUserInformation(user,membership,true,true,true).addCourseInformation(course).addCustomToolParameters(customParams).addLaunchPresentationInformation(launchPresentation);launcher.launch(req,res,true,newFormattedText("You are launching my tool. Click Submit.", FormattedText.Type.PLAIN_TEXT));
- 18. Hungry yet? Let’s make a sandwichTool Provider
- 19. Tool Provider… Tool Provider?HOW DO I WRITE A TOOL PROVIDER!!!You could:Go to http://www.imsglobal.org/ltiDownload the Basic LTI specRead the specImplement the Tool Provider side of the specFind bugs, tear out hair, fix bugs.Rinse, Repeat until working.Benefit:You can use any language to do thisLike Ruby? Ok. Like PHP? Ok. Like Node.js? Ok.
- 20. BLTI-sandwich to the Rescue!But… If you like JavaI’ve done this for you!BLTI-sandwichhttp://projects.oscelot.org/gf/project/blti-sandwich/Simple Java library that implements the glue between Tool Consumers and Tool ProvidersImplements Basic LTI 1.0Mostly for creating Tool ProvidersCan also use to help create a Tool Consumer
- 21. BLTI-SandwichTwo main classes to deal withBLTIMessageContains all of the Basic LTI launch data in an easy to use formatBLTIProviderAllows you to pull a BLTIMessage off of an HttpServletRequest and validate it.
- 22. BLTIMessageContainer for Basic LTI Launch DataE.g.msg.getKey()msg.getResourceLink().getId()msg.getUser().getFullName()msg.getUser().isInRole( Role.CONTEXT_NAMESPACE, Role.MENTOR )msg.getContext().getLabel()msg.getLaunchPresentation().getReturnUrl()msg.getCustomParameters().get("the-custom-param")
- 23. BLTIProviderStatic methods to grab Basic LTI launch data and validate it.BLTIMessagegetMessage(HttpServletRequest request)Pulls launch data off the request.booleanisValid(BLTIMessagemsg, String secret)Checks whether the message contains all of the required Basic LTI fields and was signed using the specified shared secret.
- 24. Let’s make a toolSimple polling toolLet instructor create an ad-hoc pollLet students vote (and see results)Let instructors see detailed results (who voted on what)What we’ll useblti-sandwichSpring MVCGoogle App EngineObjectify (App Engine Datastore ORM)
- 25. Demo Timehttp://blti-sandwich.appspot.comRunning on App Engine
- 26. Code Walkthrough
- 27. /** * Performs the Basic LTI launch using blti-sandwich. */@RequestMapping("/blti/tool")publicStringlaunch(HttpServletRequestrequest){// Parse out the BLTI launchBLTIMessagemsg=BLTIProvider.getMessage(request);// Load the consumer that matches the key passed in the launchConsumerconsumer=consumerDAO.get(Consumer.generateKey(msg.getKey()));// Validate the message (make sure the message was signed by the shared secret)if(consumer==null||!BLTIProvider.isValid(msg,consumer.getSharedSecret())){returnerrorRedirect(msg,"Error: Not Authorized!");}// [More validation edited out here...]else{// Provision a user objectprovisionUser(msg,consumer);// Set up the HTTP session for the userHttpSessionsession=request.getSession(false);if(session!=null){session.invalidate();}session=request.getSession();// Keep the BLTI message in session for use in other pages.session.setAttribute("bltiSessionMsg",msg);// Redirect to the tool (Poll) display pagereturn"redirect:/blti/tool/index";}}
- 28. ResourcesIMS http://www.imsglobal.org/toolsinteroperability2.cfmLearn Help Center http://help.blackboard.comblti-sandwich library on OSCELOT http://projects.oscelot.org/gf/project/blti-sandwich/This presentation and example code will be available via http://edugarage.com at some point after the conference ends.jim.riecken@blackboard.comdan.rinzel@blackboard.com
- 29. Please provide feedback for this session by emailingDevConFeedback@blackboard.com. The title of this session is:Code Your Own: Tool Integration Using the Basic Learning Tools Interoperability (LTI) Standard
Editor's Notes
- #2: Originally presented Monday, July 11th at 10AM Pacific Time in Titian 2310B at the Sands Expo Center in the Venetian hotel, Las Vegas, Nevada, USA as part of the Blackboard Developers’ Conference 2011.
- #3: The first release of Blackboard Learn to provide Tool Consumer support forthe Basic LTI standard from IMS was Service Pack 4 of Release 9.1, which was released on December 29, 2010.The features and techniques covered in this presentation apply to that release and any subsequent Service Pack release of Learn 9.1.
- #4: Agenda for the presentation.
- #5: The goal is to transform the cobbling-together of interfaces between tools and platforms, by promoting a standard “plug” mechanism. Our situation today is very much like the “bag of adapters” on the left – a tool has to identify which platforms (and sometimes which versions of which platforms) it can support, with different installation and configuration instructions for each. What LTI proposes is that we move to a world more like the Universal Serial Bus world, where everybody uses the same connector.Yes this analogy is imperfect, USB isn’t always a power source, there are a couple different kinds of USB connectors, but hopefully you get the idea
- #6: The full LTI specification includes a whole set of two-way communication – ways for the tool to query the platform for information about what it supports, and to negotiate various levels of security and integration and notification on various events that might take place on the platform.The basic LTI specification is vastly simpler. A user is “launched” from the platform to the tool, with some information passed in the launch payload that allows a trust relationship to be established and some contextual data passed to the tool that can allow a personalized experience of the tool for the user, including facilitating their return to the platform.
- #7: A tool provider doesn’t have to be centrally hosted, but that’s generally the case and we think it will continue to grow in that direction
- #8: Learning management system, virtual learning environment, etcetc – really any “platform” for teaching and learning.Blackboard Learn peforms this role in two waysAn on-board tool consumer that the administrator can configureA Building Block accessible framework to do launches Both approaches are currently in use, the Wimba Voice tools and the McGraw-Hill integration between Learn and the McGraw-Hill Connect service both leverage Basic LTI
- #9: If enabled, the on-board default tool consumer is baked directly into the existing Create URL workflow, by means of a simple checkbox with field-level help. > Choosing the checkbox will treat the URL as a Basic LTI launch instead of a “plain” URL> If the provider is not yet registered on the system, as in the screenshot here, the system “reveals” an additional set of fields to configure the credentials and optional custom parameters required by the tool> These must be negotiated beforehand outside the software> If the provider has already been registered at the system level, this additional configuration work is usually unnecessaryI’ll show how this works on a live system now, and we’ll talk about the various configuration options available at the global level, as well as additional tools available at the course levelThen, I’ll hand it over to Jim to cover the additional options available with deployment via Building Block, and how to code the tool provider end of things.SWITCH TO DEMO SCRIPT
- #10: Turn it over to Jim
- #11: You might be asking “Why would I use a Building Block” when instructors can create links themselves?Having to know keys and secrets and urls can be confusing for some users. They just want to be able to use a toolThey need not even know that the tool is on another server.You can create a more seamless integration by using the placement points B2s allowE.g. A Tool placement – allows you to launch from the course menu, or even a system admin tool.E.g. A Custom content handler – allows you to launch to a specific piece of custom contentCustom create/edit page – set custom paramters for launch
- #13: In order to use BLTI in a B2 you have to indicate what servers you are going to access and what user data (if any) you are going to send to the server.The admin will see these permissions when activating the B2 and can decide not to install the B2 because they do not want information to be sent. So, only request permissions you actually need.
- #14: Pause for questions
- #15: BasicLTI launcher lets you easily perform a Basic LTI launch from a Bulding BlockCan add information about user/courseCan add custom parametersCan add launch information parametersWill automatically add information about the BbLearn instance (e.g. admin email, current locale, etc)You don’t have to use the automatic launch page. It’s possible to get the signed parameters and create your own launch.
- #16: Note that for the addUser methods, SecurityExceptions will be thrown if you do not have the appropriate permissions in your bb-manifest.xmlThe population methods all return the instance of BasicLTILauncher (so you can chain them together)For launching you can either use the automatic launch (with the launch method) or manually construct a launch page of your own.If you are creating a custom launch JSP, make sure that you either:Submit the form using JavaScriptOr make sure the submit button has no "name" attributeOtherwise, the text of the submit button will be added as a POST parameter and cause OAuth validation to fail (as the parameter value was not included in the signature).
- #17: First example is a minimal launch – only data strictly required by the specSecond adds the current user and course from Context and uses a splash screen confirmation.
- #18: Finally we have the kitchen sink which does a bit of everythingAdd a specific user and courseAdd information about the resourceAdd custom parametersAdd launch presentation informationPause for questions
- #19: Jim’s DemoBLTI-sandwich Java library – source code released on OSCELOTDemo tool provider & show source code built on the sandwich
- #20: To create a tool provider you need to implement the tool provider side of the Basic LTI spec.You can use any language to do this – it doesn’t matter (as long as you can service HTTP requests and do Oauth signatures)You also need an external server – as this does not run inside of Learn like a Building BlockBonus is that your tool will work for any Basic LTI consumer – you don’t have to rewrite plugin code for each new LMS that comes out. Write once, launch anywhere.
- #21: If you’re using Java on your server, I’ve written a simple library called blti-sandwich that implements the Basic LTI specIt’s open source and up on OSCELOT right now – download away!Can be used to help create a Tool Consumer, but I’m going to focus on the Tool Provider side.
- #22: There are two main classes to deal with in BLTI Sandwich for creating a Tool ProviderBLTIMessage – this is a data object that contains all of the launch data from the BLTI request – e.g. resource info, context info, user info, custom parameters, etc. It’s serializable so you can for example put it into an HttpSession attribute.BLTIProvider – this allows you to pull a BLTIMessage off of an HttpServletRequest, and then validate it (with a shared secret)So all in all to process + validate a BLTI request you need to make 2 method calls. Simple!
- #23: Serializable
- #24: Pause for questions
- #25: So, let’s use blti-sandwich to create a Tool Provider!A simple polling toolWe’ll use:blti-sandwich for Basic LTI processingSpring MVC for our application logicGoogle App Engine to host the toolAnd Objectify for storing data in the App Engine datastore.Mostly I’m just going to focus on the BLTI stuff – not going into super detail on appengine or spring stuff.
- #26: It’s up and running right now on App Engine at http://blti-sandwich.appspot.comShow demo of toolAs instructor creating link to tool – show that poll title + description are autopopulated – also separate pages for instructor vs studentCreate a poll as instructorAs student(s) answer pollGo back as instructor and see resultsTool requires user data to be sent (name + role at least)Poll is linked to consumer key + resource id – users are linked to consumer key + user id
- #27: Code walkthrough time. Open up eclipseOverview the projectModels – Consumer, User, Poll, PollResultDAOs – persistenceControllers – focus mostly on the launch controller and how it does the blti-sandwich stuff.
- #28: Covered this in detail from inside eclipse. Placeholder slide in case of IDE fail.
- #29: IMS for the spec, examples and conformance testing tools (to get your IMS badge)Learn help center for the instructor and admin “onboard” tools used with Create URLOSCELOT for the source code of the sandwich library