Code Your Own: Tool Integration using the Basic Learning Tools Interoperability (LTI) Standard
•Download as PPTX, PDF•
9 likes•6,901 views
Originally presented by Jim Riecken and Dan Rinzel of Blackboard Learn Product Development on 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. This presentation covers Blackboard Learn's capabilities as a Tool Consumer according to the IMS specificiations for Learning Tools Interoperability, beginning with the Service Pack 4 release of Learn 9.1 in December of 2010.
Recommended
More Related Content
Similar to Code Your Own: Tool Integration using the Basic Learning Tools Interoperability (LTI) Standard
Similar to Code Your Own: Tool Integration using the Basic Learning Tools Interoperability (LTI) Standard (20)
Recently uploaded
Recently uploaded (20)
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#blticode Jim Riecken & Dan Rinzel Blackboard Learn Product Development
- 2. Basic Learning Tools Interoperability with Blackboard Learn™, Release 9.1 SP4
- 3. Q’s we will try to A What 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, Simplify one launch mechanism with one security policy no 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 platform Launch mechanism and authN as specified, including extra data in the launch “payload”
- 7. What’s a Tool Consumer? A LMS, VLE or portal environment Sets 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 integration Tool placement Content Handler placement Bypass global provider settings Permissions declared in bb-manifest.xml Instructors don’t need to deal with URLs, Keys, and Secrets They might not even know that the tool is running on another server!
- 11. How to use Basic LTI in a Blackboard Building Block Two Parts Declare permissions in bb-manifest.xml Use blackboard.platform.blti.BasicLTILauncher In your Tool page or Content Handler view page
- 12. Basic LTI Permissions New “basiclti” permission type. Name is the domain you intent to launch to. Use “*” if you want to launch to any domain Specifying a domain allows subdomains as well Value 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. BasicLTILauncher Encapsulates the logic for performing a Basic LTI launch. blackboard.platform.blti.BasicLTILauncher blackboard.platform.blti.BasicLTIConstants Simple API Can add user/course information Can add custom parameters Does OAuth signing and redirects to an automatic launch page.
- 15. BasicLTILauncher Constructor BasicLTILauncher(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) Launch Map<String,String> prepareParameters() void launch(HttpServletRequestreq, HttpServletResponse res, booleanuseSplashScreen, FormattedTextsplashScreenMessage)
- 16. BasicLTILauncher - Examples Simple Launch BasicLTILauncherlauncher=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 message BasicLTILauncherlauncher=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 - Examples The kitchen sink Useruser=...;// Get user somehow Coursecourse=...;// Get course somehow CourseMembershipmembership=...;// Get user membership in course Map<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/lti Download the Basic LTI spec Read the spec Implement the Tool Provider side of the spec Find bugs, tear out hair, fix bugs. Rinse, Repeat until working. Benefit: You can use any language to do this Like Ruby? Ok. Like PHP? Ok. Like Node.js? Ok.
- 20. BLTI-sandwich to the Rescue! But… If you like Java I’ve done this for you! BLTI-sandwich http://projects.oscelot.org/gf/project/blti-sandwich/ Simple Java library that implements the glue between Tool Consumers and Tool Providers Implements Basic LTI 1.0 Mostly for creating Tool Providers Can also use to help create a Tool Consumer
- 21. BLTI-Sandwich Two main classes to deal with BLTIMessage Contains all of the Basic LTI launch data in an easy to use format BLTIProvider Allows you to pull a BLTIMessage off of an HttpServletRequest and validate it.
- 22. BLTIMessage Container for Basic LTI Launch Data E.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. BLTIProvider Static 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 tool Simple polling tool Let instructor create an ad-hoc poll Let students vote (and see results) Let instructors see detailed results (who voted on what) What we’ll use blti-sandwich Spring MVC Google App Engine Objectify (App Engine Datastore ORM)
- 25. Demo Time http://blti-sandwich.appspot.com Running on App Engine
- 26. Code Walkthrough
- 27. /** * Performs the Basic LTI launch using blti-sandwich. */ @RequestMapping("/blti/tool") publicStringlaunch(HttpServletRequestrequest) { // Parse out the BLTI launch BLTIMessagemsg=BLTIProvider.getMessage(request); // Load the consumer that matches the key passed in the launch Consumerconsumer=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 object provisionUser(msg,consumer); // Set up the HTTP session for the user HttpSessionsession=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 page return"redirect:/blti/tool/index"; } }
- 28. Resources IMS http://www.imsglobal.org/toolsinteroperability2.cfm Learn Help Center http://help.blackboard.com blti-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.com dan.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
- 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.
- 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.
- Agenda for the presentation.
- 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
- 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.
- 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
- 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
- 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
- Turn it over to Jim
- 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
- 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.
- Pause for questions
- 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.
- 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).
- 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.
- 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
- Jim’s DemoBLTI-sandwich Java library – source code released on OSCELOTDemo tool provider & show source code built on the sandwich
- 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.
- 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.
- 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!
- Serializable
- Pause for questions
- 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.
- 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
- 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.
- Covered this in detail from inside eclipse. Placeholder slide in case of IDE fail.
- 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