Code Your Own: Tool Integration using the Basic Learning Tools Interoperability (LTI) Standard
Upcoming SlideShare
Loading in...5
×
 

Code Your Own: Tool Integration using the Basic Learning Tools Interoperability (LTI) Standard

on

  • 3,805 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 ...

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.

Statistics

Views

Total Views
3,805
Views on SlideShare
3,749
Embed Views
56

Actions

Likes
3
Downloads
19
Comments
0

3 Embeds 56

http://jimharland.tumblr.com 53
https://twitter.com 2
http://www.tumblr.com 1

Accessibility

Categories

Upload Details

Uploaded via as Microsoft PowerPoint

Usage Rights

© All Rights Reserved

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Processing…
Post Comment
Edit your comment
  • 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

Code Your Own: Tool Integration using the Basic Learning Tools Interoperability (LTI) Standard Code Your Own: Tool Integration using the Basic Learning Tools Interoperability (LTI) Standard Presentation Transcript

  • Code Your Own Tool Integration Using the Basic Learning Tools Interoperability (LTI) Standard#blticode
    Jim Riecken & Dan Rinzel
    Blackboard Learn Product Development
  • Basic
    Learning
    Tools
    Interoperability
    with Blackboard Learn™, Release 9.1 SP4
  • 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
  • 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
  • What is Basic LTI?
    Simplify, Simplify, Simplify
    one launch mechanism with one security policy
    no access to run-time services on the platform
  • 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”
  • What’s a Tool Consumer?
    A LMS, VLE or portal environment
    Sets policy about the payload privacy, who can provision links
  • What does that look like in Blackboard Learn?
  • Basic LTI & Blackboard Building Blocks™
  • 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!
  • 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
  • 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.
  • 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" />
  • 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.
  • 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)
  • 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));
  • 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));
  • Hungry yet? Let’s make a sandwichTool Provider
  • 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.
  • 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
  • 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.
  • 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")
  • 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.
  • 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)
  • Demo Time
    http://blti-sandwich.appspot.com
    Running on App Engine
  • Code Walkthrough
  • /**
    * 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";
    }
    }
  • 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
  • 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