Chris Mayo's Blog - Unified Communications Development : OC 2007 SDK

How to save IM conversations using Office Communicator SDK

cmayo — Thu, 10 Sep 2009 19:57:00 GMT

Archiving the contents of an IM conversation using the Office Communicator SDK is something that I get asked about pretty routinely. For example, let’s say that you want to launch an IM call from your application using the OC SDK and archive that conversation to be retrieved later (displaying all the application specific conversations in your application or on a SharePoint site, etc.).

The OC SDK provides the IMessengerConversationWndAdvanced.History property to access the body of an IM conversation. For example, the following console application launches an IM call and then writes out the IM history to the console:

   1:  namespace History

   2:  {

   3:      class Program

   4:      {

   5:          private static Messenger _messenger;

   6:          private static IMessengerAdvanced _messengerAdv;

7:

   8:          private static long _myConvHWND = 0;

   9:          private static IMessengerConversationWndAdvanced _myConv;

10:

  11:          static void Main(string[] args)

  12:          {

  13:              _messenger = new Messenger();

  14:              _messengerAdv = (IMessengerAdvanced)_messenger;

15:

  16:              _messenger.OnIMWindowCreated +=

  17:                  new DMessengerEvents_OnIMWindowCreatedEventHandler(

  18:                  _messenger_OnIMWindowCreated);

  19:              _messenger.OnIMWindowDestroyed +=

  20:                  new DMessengerEvents_OnIMWindowDestroyedEventHandler(

  21:                  _messenger_OnIMWindowDestroyed);

22:

  23:              object[] sipUris = new object[] { "kf@fabrikam.com", "cb@fabrikam.com"  };

24:

  25:              object obj = _messengerAdv.StartConversation(

  26:                  // The call media.

  27:                  CONVERSATION_TYPE.CONVERSATION_TYPE_IM,

  28:                  // The participants.

  29:                  sipUris,

  30:                  // Not supported.

  31:                  null,

  32:                  // The conversation window title as as string.

  33:                  "Account: Johnson (ID:12345)",

  34:                  // Not supported.  Pass "1".

  35:                  "1",

  36:                  // Not supported.

  37:                  null);

38:

  39:              _myConvHWND = long.Parse(obj.ToString());

40:

  41:              Console.WriteLine(

  42:                  "Press the Enter key to see IM conversation History.");

  43:              Console.ReadLine();

44:

  45:              if (_myConv != null)

  46:              {

  47:                  try

  48:                  {

  49:                      Console.WriteLine(_myConv.History);

  50:                  }

  51:                  catch (COMException ce)

  52:                  {

  53:                      Console.WriteLine(

  54:                          "COM Exception " + ce.ErrorCode.ToString());

  55:                  }

  56:              }

57:

  58:              Console.WriteLine("Press the Enter key to exit the application.");

  59:              Console.ReadLine();

60:

  61:              _messenger.OnIMWindowCreated -=

  62:                  new DMessengerEvents_OnIMWindowCreatedEventHandler(

  63:                  _messenger_OnIMWindowCreated);

  64:              _messenger.OnIMWindowDestroyed -=

  65:                  new DMessengerEvents_OnIMWindowDestroyedEventHandler(

  66:                  _messenger_OnIMWindowDestroyed);

67:

  68:              Marshal.ReleaseComObject(_messenger);

  69:              _messenger = null;

  70:              Marshal.ReleaseComObject(_messengerAdv);

  71:              _messengerAdv = null;

72:

  73:              if (_myConv != null)

  74:              {

  75:                  Marshal.ReleaseComObject(_myConv);

  76:                  _myConv = null;

  77:              }

  78:          }

In the code above, I’m registering for the OnIMWindowCreated and OnIMWindowDestroyed events to get and release my reference to the conversation window (_myConv) so I can access the History property. The code below shows how I manage the _myConv reference:

   1:          static void _messenger_OnIMWindowCreated(object pIMWindow)

   2:          {

   3:              IMessengerConversationWndAdvanced newConv =

   4:                  (IMessengerConversationWndAdvanced)pIMWindow;

5:

   6:              if (newConv.HWND == _myConvHWND)

   7:              {

   8:                  newConv.SendText("This is a ongoing conversation " +

   9:                      "about the Account: Johnson (ID:12345) " +

  10:                      "and will be saved on the account site.");

11:

  12:                  _myConv = newConv;

  13:              }

  14:          }

15:

  16:          static void _messenger_OnIMWindowDestroyed(object pIMWindow)

  17:          {

  18:              if (object.ReferenceEquals((object)_myConv, pIMWindow))

  19:              {

  20:                  Marshal.ReleaseComObject(_myConv);

  21:                  _myConv = null;

  22:              }

  23:          }

In OnIMWindowCreated, I set _myConv using the pIMWindow object passed as an event argument after confirming it’s the conversation I started in code (by comparing the HWNDs). When OnIMWindowDestroyed fires, I check to make sure the window being destroyed is mine by using object.ReferenceEquals and release the reference. Note that I can’t use the HWND property in OnIMWindowDestroyed since conversation window no longer exists and _myConv is no longer a valid reference.

While this code works, it’s not an ideal solution. I can’t rely on the user to do something (click a button, etc.) in my app before the conversation is closed. I’d rather just write the IM conversation history out when the conversation is completed. This leads a lot of developers to try the following:

   1:          static void _messenger_OnIMWindowDestroyed(object pIMWindow)

   2:          {

   3:              if (object.ReferenceEquals((object)_myConv, pIMWindow))

   4:              {

   5:                  Console.WriteLine(_myConv.History);

6:

   7:                  Marshal.ReleaseComObject(_myConv);

   8:                  _myConv = null;

   9:              }

  10:          }

But, the call to IMessengerConversationWndAdvanced.History throws an exception since _myConv is no longer a valid reference when OnIMWindowDestroyed fires.

Another solution I’ve seen is polling History on another thread through the life of the conversation and writing out the last value when the conversation window is destroyed. While this works, it’s less than ideal due to the resource you consume.

So what does provide a good working scenario? Creating a UCMA 2.0 IM robot that archives conversations and inviting that bot to all the conversations you want archived is a great solution (and a great future blog post).

Details on how to start conversations using the Office Communicator SDK can be found in the How to make calls via Office Communicator SDK and How to send IM text using Office Communicator SDK posts on this blog.

If you’d like to try this code out for yourself, you’ll need to download the Office Communicator 2007 SDK and setup a UC development environment.

More details, tips and tricks on UC development can be found in the Programming for Unified Communications book.

Thanks,

Chris

How to send IM text using Office Communicator SDK

cmayo — Sat, 29 Aug 2009 19:32:53 GMT

When starting call from your application using the Office Communicator Automation API, it’s often helpful to send some IM text to provide some context for the call (often using data from your application). For example, Outlook 2007 does this when you start a conversation using the IM and Call features from an email.

When the call is placed, Outlook 2007 uses the OC API to set the conversation window title and to provide details on the subject of the call (the email) via IM.

Here is a quick video that shows how to send IM text using the Office Communicator Automation API:

Let’s break down some of the details from the video. First, the IMessengerAdvanced.StartConversation() method is used to start the call. Once the call is accepted by the callee, a conversation window is created that I can use to send IM as part of the call. Due to the asynchronous nature of the OC API, this conversation window doesn’t get created right away. Luckily, the StartConversation() method returns the HWND of the conversation window so I can identify it in code when it is created. Registering for the OnIMWindowCreated event will give me access the conversation window when that happens. For example, the following code registers for the OnIMWindowCreated event, starts a new audio call and stores the HWND of conversation window to be created in a local variable _myConvHWND:

   1:  namespace StartConversation

   2:  {

   3:      class Program

   4:      {

   5:          private static Messenger _messenger;

   6:          private static IMessengerAdvanced _messengerAdv;

7:

   8:          private static long _myConvHWND = 0;

9:

  10:          static void Main(string[] args)

  11:          {

  12:              _messenger = new Messenger();

  13:              _messengerAdv = (IMessengerAdvanced)_messenger;

14:

  15:              _messenger.OnIMWindowCreated += new DMessengerEvents_OnIMWindowCreatedEventHandler(_messenger_OnIMWindowCreated);

16:

  17:              object[] sipUris = new object[] { "kf@fabrikam.com" };

18:

  19:              object obj = _messengerAdv.StartConversation(

  20:                  // The call media.

  21:                  CONVERSATION_TYPE.CONVERSATION_TYPE_AUDIO,

  22:                  // The participants.

  23:                  sipUris,

  24:                  // Not supported.

  25:                  null,

  26:                  // The conversation window title as as string.

  27:                  "My Audio Call with IM as Context",

  28:                  // Not supported.  Pass "1".

  29:                  "1",

  30:                  // Not supported.

  31:                  null);

32:

  33:              _myConvHWND = long.Parse(obj.ToString());

34:

  35:              Console.WriteLine("Press the Enter key to exit the application.");

  36:              Console.ReadLine();

37:

  38:              _messenger.OnIMWindowCreated -= new DMessengerEvents_OnIMWindowCreatedEventHandler(_messenger_OnIMWindowCreated);

39:

  40:              Marshal.ReleaseComObject(_messenger);

  41:              _messenger = null;

  42:              Marshal.ReleaseComObject(_messengerAdv);

  43:              _messengerAdv = null;

  44:          }

When OnIMWindowCreated fires, it passes a reference to the conversation window via the IMessengerConversationWindowAdvanced interface. I can use the HWND property on this interface to see if the conversation is the one I created with StartConversation() and send some IM using the SendText() method. I need to check the HWND since OnIMWindowCreated will fire for every new conversation windows created by OC 2007 R2 (incoming or outgoing). For example:

   1:          static void _messenger_OnIMWindowCreated(object pIMWindow)

   2:          {

   3:              IMessengerConversationWndAdvanced newConv = (IMessengerConversationWndAdvanced)pIMWindow;

4:

   5:              if (newConv.HWND == _myConvHWND)

   6:              {

   7:                  newConv.SendText("This IM was sent via SendText()...");

   8:              }

   9:          }

Using the SendText() method to provide some application data in the IM channel is a great way to add value to the calls you launch from your application. Using the Outlook 2007/Office Communicator 2007 R2 integration as an example, you can start to think of ways that you can provide context to the calls your application launches using data from your application.

If you’d like to try this code out for yourself, you’ll need to download the Office Communicator 2007 SDK and setup a UC development environment.

More details, tips and tricks on UC development can be found in the Programming for Unified Communications book.

Thanks,

Chris

PDC09 registration open, Unified Communications Futures session posted

cmayo — Tue, 18 Aug 2009 23:01:36 GMT

Before I joined Microsoft back in 2000, if I could only attend one conference a year it would be the PDC. The opportunity to get a firsthand look at the future of the Microsoft platform and provide feedback directly to the product teams just couldn’t be passed up. Other conferences do a great job showing how to get things done today, the PDC is all about how to get things done in the future.

Now that I’m with Microsoft and in a role where I focus on the future of the Unified Communications Platform, I feel the same way. I wouldn’t miss PDC09 for anything. At the PDC last year, we shared details on the platform we released along with Office Communications Server 2007 R2 and Exchange 2010 and provided details on v.Next.

At PDC09, we’ll share specific details v.Next, including the UC product futures (including Office Communications Server, Office Communicator and Exchange) and platform futures (both client and server side) as well as sharing details on early adopter programs.

Details on registering for PDC09 and the Microsoft Unified Communications: Developer Platform Futures can be found on the PDC09 site. You can watch the UC futures session at PDC08 to get a hint of what is coming.

Let’s get together while we’re there.

Thanks,

Chris.

Announcing the OCS 2007 R2 Platform SDKs and New Exchange API…

cmayo — Tue, 28 Oct 2008 07:52:31 GMT

Today Chris Schindler and I presented a session at the PDC, BB09 – Office Communications Server 2007 and Exchange 2007: Platform Futures. This is the first time we’ve discussed the new R2 platform SDKs and the new Exchange Web Services Managed API outside of the beta program and the first time we’ve discussed v.Next in public.

Man, it’s great to be able to talk about we’ve been working on with the OCS and Exchange platform teams. So, here are details on the new platform.

OCS 2007 R2:

Along with the release of Office Communications Server 2007 R2 and Office Communicator 2007 R2, we’re going to be releasing some new APIs. The main focus of the this release is on the server side, providing more capabilities for building services that provide communication features. Here are some details on the release:

Unified Communications Managed API 2.0 – UCMA 1.0 provided a high scale/availability managed SIP stack for signaling and IM communications. It was a great API for building broadcast IM solutions or IM based query/response bots. UCMA 2.0 builds on the 1.0 version with new features:

Presence: Now you can publish presence directly from the API as well as subscribe to the presence of other contacts and receive changes in presence as events. UCMA 2.0 also supports snapshot presence queries to get the presence of contacts at a particular point in time.
Audio: Voice communications and audio call management is now supported in this release.
Conferencing: Conferencing calls (IM or voice) and conference management is now supported.

Unified Communications Managed API 2.0 Windows Workflow Activities – Built on UCMA 2.0, these workflow activities allow you to build workflows based on incoming and outgoing calls. The activities include:

IM and Speech Dialog Activities: Including statement and question activities for both IM and voice calls. These activities provide various prompts to make the conversation feel very natural and SGRS grammars to help map what the callee says to the answers you expect.
Commands: Commands allow you to define global commands when asking a question in your workflow. This allows the user to ask for help, ask for the prompt to be repeated or enact custom commands (such as “Speak to a representative.”).
Events: Events allow you to provide custom workflows for dialog events (for example, not being able to understand what was said) as well as communication events (such as the call being disconnected).
Presence: The GetPresence activity allows you to query the presence of the contacts specified in order to use in that presence in the logic of your workflow.

The Office Communicator 2007 SDK is unchanged in R2. This API allows you to integrate presence, IM, voice, video and conferencing by automating OC 2007 or OC 2007 R2 on the client machine.

Exchange 2007: Released with Exchange 2007, Exchange Web Services provides you access to the Exchange 2007 mailbox store and services such as Availability and Notifications via a single API. Exchange Web Services is *the* API for Exchange 2007 development. The new EWS Managed API provides you access to EWS functionality in a new managed API that feels much like developing with the rest of the .NET Framework rather than a set of proxy classes.

I’ll post a link to the session as soon as it’s up. We had some A/V and network issues with my first demo so I’ll record that demo again and post that too so you can get a complete picture of what the platform can do.

I had a lot of people approach me about getting access to the Beta in our Metro early adopter program. There are still spots left. Please contact me via the contact page here or see me and the PDC in the booth and we’ll discuss if your project is a good fit for the program.

Lastly, thanks to the product teams (Chris, Kyle, Oscar, Vishwa, Stephane, Vincent), technical product marketing (Albert and Adam) and the folks and Clarity Consulting for their help with the session today. Much appreciated.

Thanks,

Chris

I’m here @ PDC08

cmayo — Mon, 27 Oct 2008 08:50:18 GMT

Flight was on time(ish). Hotel is close to the convention center. All my hardware got here in one piece (though there’s actually like 14 pieces). I’ve been running through my demos and everything is looking good.*

Are you ready for the PDC? Got sessions and HOLs picked out?

We’re going to be talking about the R2 platform SDKs for the first time outside of the private Beta this week at the PDC. Here are the details on sessions/rooms/etc.

BB09 Office Communications Server and Exchange: Platform Futures

Monday 10/27 – 1:45 pm @ 408A

BB45 Office Communications Server 2007 R2: Enabling Unified Communications

Monday 10/27 – 5:15 pm @ 406A

BB46 Exchange Web Services Managed API: Unified Communications Development for Exchange

Thursday 10/30 – 8:30 am @ 408B

See you there,

Chris

*If you’re in room 1923, I’m really sorry for the constant sound of phones ringing…

UC @ PDC

cmayo — Thu, 09 Oct 2008 21:15:10 GMT

The PDC (10/26-10/30 in LA) is all about the future of the Microsoft Platform.

So it’s appropriate that we’re going to be showing the next generation of OCS 2007, OC 2007 and the UC Platform SDKs for the first time at the PDC.

Learn: We’ve got a lot to show in our sessions if you look under the Unified Communications tag:

Office Communications Server and Exchange: Platform Futures

Presenters: Chris Mayo, David Ollason
Learn how applications and services can add presence, IM, VOIP, and Video using the Unified Communications Platform. Also, see the roadmap for the future of Microsoft Unified Communications (UC) products and the new UC Platform SDKs.

Exchange Web Services Managed API: Unified Communications Development for Exchange

Presenter: Jason Henderson
The new Exchange Web Services Managed API provides managed code access to Exchange, whether running on premises or in the cloud. Learn how this new Microsoft .NET API provides full access to Microsoft Exchange mail, calendaring, scheduling, contacts, eventing, synchronization, permissioning, and public folders programmatically using the Exchange Web Services protocol.

Office Communications Server 2007 R2: Enabling Unified Communications

Presenters: Oscar Newkerk, David Ollason
Learn how UCMA 2.0 and Unified Communication Workflow Activities provide a powerful communications arsenal to build Presence, IM, and voice-enabled services that can be leveraged from any application.

We’ll have some other cool things to do after/around our sessions.

Socialize: Come to the UC booth. I’m going to be there along with the rest of the UC Platform team so we can sit down and talk about the new platform SDKs, scenarios, write some code, hit the whiteboard, whatever.

Do: If you come to our sessions and get motivated to kick the tires, we’ll have HOLs at the PDC. Do the HOLs and you’ll be the first to see/touch/use the bits publically. The UC Platform team and I will be around to answer your questions and get your feedback.

Hope to see you there.

Chris

Couldn't make it to TechEd? UC Platform Webcasts in June!

cmayo — Tue, 10 Jun 2008 01:19:00 GMT

I wanted to make sure everyone had a chance to catch some webcasts I'm delivering here in the next couple of weeks.

We're going to cover a lot of the UC dev basics and take a deeper dive on a couple of APIs. Details and registration at the links below:

6/17 - Building Software on the Unified Communications Platform

6/19 - Behind the Scenes with Office Communications Server 2007, Office Communicator 2007 and Exchange 2007

6/24 - Driving Contextual Collaboration with Office Communicator 2007

6/27 - Building Asynchronous Contextual Collaboration with Exchange Web Services

Hope to see you (virtually) there.

Chris

TechEd Developers 2008 is Packed with UC Development Content

cmayo — Thu, 15 May 2008 22:00:00 GMT

Everyone that touches the UC products and SDK is heads down getting ready for TechEd 2008. It's going to be awesome.

First, we've great breakout sessions to show you how to build communications features into your apps, like IM, voice and video. We've also got Interactive Theatre sessions where we'll show and discuss deeper demos of what the SDKs can do (and it's pretty cool). Along with that, we've got HOLs built on top of a full OCS 2007 and Exchange 2007 environment where you can fire up Visual Studio and kick the tires.

Here's and example:

1. It takes about 10 lines of code to launch a voice call. We'll show you that code in the breakouts.

2. Adding communications like voice calls makes for some really compelling apps. We'll show you those apps and how we built them in the Interactive Theatre.

3. You'll be able to write that code in the HOLs to see the code in action.

Here are the sessions we'll have at TechEd:

Code	Title	Session Type	Speaker(s)
UNC201	Building Software on the Microsoft Unified Communications Platform	BRK	Albert Kooiman; Kirt Debique
UNC302	Building Asynchronous Contextual Collaboration with Microsoft Exchange Web Services	BRK	Jason Henderson; Paul Robichaux
UNC303	Unified Communications: Behind the Scenes with Microsoft Office Communications Server 2007, Office Communicator 2007 and Microsoft Exchange Server 2007	BRK	Kyle Marsh; Uma Raghavan
UNC304	Driving Contextual Collaboration with Microsoft Office Communicator 2007	BRK	Chris Mayo
UNC402	Business Process Communications with the Microsoft Unified Communications Managed API	BRK	Michael Dunn
UNC401	Building Contextual Collaboration Using the Microsoft Unified Communications Client API	BRK	Oscar Newkerk; Stefano Mapelli
UNC306	Anywhere Information Access with Microsoft Office Communications Server 2007 Speech Server	BRK	Albert Kooiman; Michael Dunn
UNC202	Programming Conferencing Solutions with the Microsoft Office Live Meeting Service XML API	BRK	John Shriver-Blake
UNC305	Building Contextual Collaboration Clients for the Web Using the Microsoft Unified Communications AJAX SDK	BRK	Rui Maximo
UNC11-TLC	I Want Unifed Communications in My Application: Tell Me How	TLC	Chris Mayo; Jon Rauschenberger
UNC03-TLC	Communicator Plus: A Microsoft Office Communicator Add-on by Eventure	TLC	Vivek Garg
UNC01-TLC	Building Mash-ups with Microsoft Exchange Server 2007 Web Services	TLC	David Claux
UNC05-TLC	Migrating Microsoft Exchange Applications to Exchange Web Services	TLC	David Claux; Jason Henderson
UNC08-TLC	How to Integrate Microsoft Unified Communications with the Microsoft Office System	TLC	Chris Mayo
UNC06-TLC	Using the Microsoft Office Communicator APIs	TLC	Avronil Bhattacharjee; Manisha Sahasrabudhe
UNC02-TLC	Building Alerts and Notifications Using the Microsoft Unified Communications Managed API	TLC	Stephane Taine
UNC09-TLC	Building an Outbound Microsoft Office Communications Server 2007 Speech Server Application Interacting with Microsoft Exchange Server 2007 Web Services	TLC	Albert Kooiman; Jon Rauschenberger
UNC04-TLC	The Microsoft Unified Communications Client API: Building Your Own Unified Communications Client	TLC	Srivatsa Srinivasan; Stefano Mapelli
UNC07-TLC	Building Bots on the Microsoft Unified Communications Managed API	TLC	Stephane Taine
UNC10-TLC	Integrating Presence in Your Web Application Using the Microsoft Unified Communications AJAX API	TLC	Rui Maximo

To get more details on our sessions, got to https://www.msteched.com/dev/public/sessions.aspx, and select "Show Track", select "Unified Communications" and then click the "Filter" button.

To get registred for TechEd Developers 2008, you can get details here: http://www.microsoft.com/events/teched2008/developer/default.mspx.

See you there! I'll be in the UC Booth all week (when I'm not speaking at Breakouts, Interactive Theatres or helping in the HOLs!)!

Chris!

The Impact of UC in Software, A Healthcare Industry Example

cmayo — Tue, 01 Apr 2008 18:38:00 GMT

Since I got into the software industry, I've always been looking for technology that has the ability to fundamentally affect the way that people work on a daily basis. The UC platform is a great example of that postive change potential and it's a big reason why I do what I do at Microsoft.

Watch this video to get a feel for the subtle, but incredibly powerful impact that UC can have on the way the doctors on a daily basis. While the doctors and scenarios are fictional for the purpose of the demo, the video does a great job of showing the potential.

Where can integrated communications add value to the software you ship to your users? How can it change they way they work and communicate on a daily basis?

Great questions!

Cool OC 2007 Extensibility Blog Post...

cmayo — Wed, 26 Mar 2008 22:41:00 GMT

I generally like any post that starts with "While waiting for Lost to start..." and ends up with something cool, but I especially like this post since it show one of the easy ways that you can extend OC 2007 to include customer functionality.

http://blogs.claritycon.com/blogs/kevin_marshall/archive/2008/03/20/google-ajax-language-api-amp-office-communicator-custom-translation-tabs.aspx

Very cool! Or should I say, Tres Cool!

Cool UC Demo on Ch. 9

cmayo — Tue, 25 Mar 2008 03:50:00 GMT

It would seem that I've finally come up for air... I know what you're thinking, nobody can hold their breath for *that* long...

Anyway, I've got a back log of cool stuff to share over the next few weeks, starting with this demo we did at the Office Developer Confernce 2008 keynote given by Gurdeep Singh Pall,. It's a retail scenario demo with lots of cool communications features. Take a look, the demos speaks for itself.

Specail "props" to Jon Rauschenberger and George Durzi of Clarity Consulting for getting this demo done quickly and done right. Man, we didn't have anything but some cool ideas 2 weeks before the conference.

More coming your way...

7 UC Dev Sessions at TechEd Developers 2007 Europe!

cmayo — Mon, 08 Oct 2007 22:27:00 GMT

TechEd Developers 2007 Europe is in Barcelona Spain on 11/5-11/9/2007 this year. I'm very excited about this year since we're going to have a total of 7 sessions focused on developing with the UC platform, including OC 2007 SDK, OCS 2007 SDK, UCCP, UCMA, CWA AJAX APIs and Speech Server.

Sign up for TechEd and mark the sessions below on your event calendar. These sessions start out with an overview of the platform as a whole and then dive deep into the platform and SDKs. You'll leave with the solid understanding of the platform and plenty of great ideas on how you can leverage communications in your solutions.

I'll be specifically covering the Unified Communications Managed API and how you can use the UCMA to create broadcast IMs, IM Bots for information access and business process automation and other server side communications solutions.

We'll also have a booth at the event staffed with members of the team to answer questions.

Come to TechEd to get started writing UC apps!

Sessions include:

UCM201 Unified Communications for Developers: Building Communications Into Your Applications

Albert Kooiman , Kirt Debique

Microsoft Unified Communications (UC) is turning the traditionally hardware oriented communications world into software. Building the Microsoft Unified Communications Platform, with rich APIs and solid tools support is a corner stone of that strategy. This session will give an overview of what scenarios the UC Platform enables and the APIs and SDKs that Microsoft Unified Communications offers. We will demonstrate how to integrate presence, voice over IP, video and messaging into your applications as well as how to build powerful communications applications like IM-based query/response bots, outbound notifications and speech technology enabled telephony applications. Communications now can be a first class feature in Windows and Web applications. This session is the overview session of how you can leverage that capability as an developer.

Mon Nov 5 16:00 - 17:15 TBC

UCM202 Developing with Exchange Web Services

Jason Henderson , Adam Glick

Exchange 2007 unifies programmatic access to Exchange data through Exchange Web Services (EWS). EWS can be used to integrate line-of-business, ISV, and Unified Communications applications with Exchange that leverage calendaring, free-busy information, contacts, messaging, tasks, and unified messaging notifications. This session gives an overview of the Exchange Web Services APIs and their roadmap, and focuses on specific illustrations of how to use Exchange Web Services in your line-of-business applications. It includes walk-through of code examples of how to integrate data from the store into LOB applications and third party solutions, with specific examples of messaging, email notifications, auto-discover and availability services.

Thu Nov 8 17:30 - 18:45 TBC

UCM301 Office Communications Server 2007 for Developers: Under the Hood

Kyle Marsh

Office Communications Server (OCS) 2007 provides the infrastructure for communications including voice, video, IM, conferencing, speech and unified messaging. But OCS 2007 is also the cornerstone of a communications platform that you as a developer can use to build communications into your solutions. In this session we will take a look under the hood of OCS to examine the foundation components that OCS makes available for developers and what OCS components are important to developers. Learn how Communicator uses the advanced publish and subscribe features of OCS to implement its rich presence features and how developers can use the OCS’s conferencing infrastructure to provide multiparty IM, voice or video conference calls.

Mon Nov 5 17:45 - 19:00 TBC

UCM302 Integrating Presence and Communications in Your Applications using Office Communicator

Kyle Marsh

With Outlook and Office Communicator, you can see the presence of people on from, to and cc lines of an email message and start IM, voice and video conversations or conferences. In this session you’ll learn how to build this "presence" and contextual collaboration into your Web and Windows Applications! This session will be loaded with examples and demos of how you can add rich presence information and drive collaboration tools from your applications.

Tue Nov 6 10:45 - 12:00 TBC

UCM303 Embedding Communications & Presence into Your Windows Applications using Unified Communications Client API (UCCA)

Aatif Awan

Learn how to create powerful communications applications similar to Office Communicator 2007 and Live Meeting 2007 or embed Presence, Contact Management, Instant Messaging, Voice, Video and Conferencing into your existing Windows applications using Microsoft Unified Communications Client API (UCCA). UCCA is an API designed to build client applications for Office Communication Server (OCS) 2007 and in this session we’ll describe the scenarios you can build into your applications using UCCA. We’ll also explore the architecture, important interfaces and programming patterns for UCCA. Finally we’ll show you a couple of demos and take a good look at the code behind these demos.

Tue Nov 6 17:00 - 18:15 TBC

UCM304 Embedding Communications & Presence into Your Web Applications using Unified Communications AJAX SDK

Kyle Marsh

Learn how to create powerful instant messaging applications similar to Office Communicator Web Access 2007 or embed Presence, Contact Management, and Instant Messaging into your existing Web applications using the Unified Communications AJAX SDK. The Unified Communications (UC) AJAX SDK is an API designed to build browser based client applicationss for Office Communication Server (OCS) 2007 that can run within a variety of browsers (IE, Firefox, and Safari) independent of the operating system. In this session we’ll describe the scenarios you can build into your applications using UC AJAX SDK. We’ll also explore the architecture, important interfaces and programming patterns for UC AJAX SDK. Finally we’ll show you a couple of demos and take a good look at the code behind these demos.

Wed Nov 7 09:00 - 10:15 TBC

UCM305 Embedding Unified Communications into Your Business Processes and Services with the Unified Communications Managed API (UCMA)

Chris Mayo

In this session, we’ll use the Unified Communications Managed API (UCMA) to build communication into the server side. UCMA give you the ability to reach users via IM whether they are inside the corporate firewall using OC 2007 or sitting in an internet café using Communicator Web Access. Come to this session to learn how to build broadcast IM services to contact users quickly and conveniently or to move to the next step in a workflow using IM. Learn how to build a query/response IM “robot” to allow users to gather information quickly just by interacting with your service via IM.

Thu Nov 8 13:30 - 14:45 TBC