/// <summary>
/// Gets the contact's current availability value from Lync and updates the corresponding elements in the user interface
/// </summary>
private void GetAvailability()
{
//Get the current availability value from Lync
try
{
currentAvailability = (ContactAvailability)lyncClient.Self.Contact.GetContactInformation(ContactInformationType.Availability);
}
catch (LyncClientException e)
{
Trace.WriteLine(e);
}
catch (SystemException systemException)
{
if (IsLyncException(systemException))
{
// Log the exception thrown by the Lync Model API.
Trace.WriteLine("Error: " + systemException);
}
else
{
// Rethrow the SystemException which did not come from the Lync Model API.
throw;
}
}
if (currentAvailability != 0)
{
//React to changed availability
}
}
private static void SetAvailability()
{
//Get the current availability value from Lync
ContactAvailability currentAvailability = 0;
try
{
currentAvailability = (ContactAvailability)lyncClient.Self.Contact.GetContactInformation(ContactInformationType.Availability);
Console.WriteLine("Availability changed: " + currentAvailability);
arduinoSerial.Set(currentAvailability);
}
catch (LyncClientException e)
{
Console.WriteLine(e);
}
catch (SystemException systemException)
{
if (IsLyncException(systemException))
{
// Log the exception thrown by the Lync Model API.
Console.WriteLine("Error: " + systemException);
}
else
{
// Rethrow the SystemException which did not come from the Lync Model API.
throw;
}
}
}
private void SetAvailability(ContactAvailability NewAvailability)
{
Trace.WriteLine("SetAvailability(" + NewAvailability.ToString() + ")");
//Add the availability to the contact information items to be published
Dictionary <PublishableContactInformationType, object> newInformation =
new Dictionary <PublishableContactInformationType, object>();
newInformation.Add(PublishableContactInformationType.Availability, NewAvailability);
//Publish the new availability value
try
{
lyncClient.Self.BeginPublishContactInformation(newInformation, PublishContactInformationCallback, null);
}
catch (LyncClientException lyncClientException)
{
Trace.WriteLine(lyncClientException);
}
catch (SystemException systemException)
{
if (IsLyncException(systemException))
{
// Log the exception thrown by the Lync Model API.
Trace.WriteLine("Lync Exception: " + systemException);
}
else
{
// Rethrow the SystemException which did not come from the Lync Model API.
throw;
}
}
}
void Contact_ContactInformationChanged(object sender, ContactInformationChangedEventArgs e)
{
string returnValue = string.Empty;
StringBuilder sb = new StringBuilder();
Boolean raiseUpdate = false;
if (e.ChangedContactInformation.Contains(ContactInformationType.Availability))
{
//get actual contactModel availability (Will be int value within OCOM availaiblity ranges)
ContactAvailability availEnum = (ContactAvailability)((Contact)sender).GetContactInformation(ContactInformationType.Availability);
string activityString = (string)((Contact)sender).GetContactInformation(ContactInformationType.Activity);
sb.Append(availEnum.ToString() + " " + activityString);
raiseUpdate = true;
}
if (raiseUpdate)
{
returnValue = "Updated availability for "
+ ((Contact)sender).GetContactInformation(ContactInformationType.DisplayName).ToString()
+ System.Environment.NewLine
+ sb.ToString();
}
Dictionary <PublishableContactInformationType, object> publishState = new Dictionary <PublishableContactInformationType, object>();
publishState.Add(PublishableContactInformationType.Availability, ContactAvailability.Free);
writeMessage("simulate mouse click" + DateTime.Now.ToString());
DoMouseClick();
//_lyncClient.Self.BeginPublishContactInformation(publishState, publishState_callback, null);
}
public void setClient(ContactAvailability pres)
{
//$pres = new PresenceStateExtensions();
Dictionary <PublishableContactInformationType, object> newInformation =
new Dictionary <PublishableContactInformationType, object>();
newInformation.Add(PublishableContactInformationType.Availability, pres);
//Publish the new availability value
try
{
lyncClient.Self.BeginPublishContactInformation(newInformation, PublishContactInformationCallback, null);
}
catch (LyncClientException lyncClientException)
{
Console.WriteLine(lyncClientException);
}
catch (SystemException systemException)
{
if (IsLyncException(systemException))
{
// Log the exception thrown by the Lync Model API.
Console.WriteLine("Error: " + systemException);
}
else
{
// Rethrow the SystemException which did not come from the Lync Model API.
throw;
}
}
}
private static char GetAvailabilityChar(ContactAvailability currentAvailability)
{
switch (currentAvailability)
{
case ContactAvailability.Free:
return('a');
case ContactAvailability.Away:
return('w');
case ContactAvailability.Busy:
return('b');
case ContactAvailability.BusyIdle:
return('b');
case ContactAvailability.DoNotDisturb:
return('d');
case ContactAvailability.FreeIdle:
return('a');
case ContactAvailability.TemporarilyAway:
return('w');
case ContactAvailability.Offline:
return('r');
default:
return('r');
}
}
private void Contact_ContactInformationChanged(object sender, ContactInformationChangedEventArgs e)
{
Debug.WriteLine("Contact information changed");
if (e.ChangedContactInformation.Contains(ContactInformationType.Activity) || e.ChangedContactInformation.Contains(ContactInformationType.Availability))
{
var activity = _client.Self.Contact.GetContactInformation(ContactInformationType.ActivityId);
ContactAvailability availability = (ContactAvailability)_client.Self.Contact.GetContactInformation(ContactInformationType.Availability);
if (availability == ContactAvailability.Busy && activity.ToString().ToLower() == "on-the-phone")
{
if (!_pauseEnabled)
{
TriggerPauseButton(activity.ToString());
_pauseEnabled = true;
UpdateStatus();
}
}
else
{
if (_pauseEnabled)
{
TriggerPauseButton(activity.ToString());
_pauseEnabled = false;
UpdateStatus();
}
}
}
}
private void SetupLyncLogitechLED()
{
try
{
if (lc == null)
{
lc = Microsoft.Lync.Model.LyncClient.GetClient();
lc.StateChanged += Lc_StateChanged;
}
}
catch (ClientNotFoundException ex)
{
MessageBox.Show("Skype for business is not running", "Program Terminated Unexpectedly",
MessageBoxButtons.OK, MessageBoxIcon.Error);
WaitTillLyncUp();
}
if (lc.State == Microsoft.Lync.Model.ClientState.SignedIn)
{
lc.Self.Contact.ContactInformationChanged += Contact_ContactInformationChanged;
ContactAvailability availability = (ContactAvailability)lc.Self.Contact.GetContactInformation(ContactInformationType.Availability);
ChangeColor(availability);
}
}
private void SetAvailability()
{
//Get the current availability value from Lync
ContactAvailability currentAvailability = 0;
currentAvailability = (ContactAvailability)lyncClient.Self.Contact.GetContactInformation(ContactInformationType.Availability);
if (currentAvailability != 0)
{
switch (currentAvailability)
{
case ContactAvailability.Away:
// do something when away
Console.WriteLine("I am Away...");
break;
case ContactAvailability.Busy:
// do something when busy
Console.WriteLine("I am Busy!");
break;
case ContactAvailability.DoNotDisturb:
// do something when DND
Console.WriteLine("Please DND");
break;
case ContactAvailability.Free:
// do something when FREE
Console.WriteLine("I am Free!");
break;
}
}
}
private void SetAvailability()
{
//Get the current availability value from Lync
ContactAvailability currentAvailability = 0;
try
{
currentAvailability = (ContactAvailability)lyncClient.Self.Contact.GetContactInformation(ContactInformationType.Availability);
string currentAvailabilityName = Enum.GetName(typeof(ContactAvailability), currentAvailability);
OnAvailabilityChanged(new AvailabilityChangedEventArgs(currentAvailability, currentAvailabilityName));
ChangeStatus(currentAvailability);
}
catch (LyncClientException e)
{
Console.WriteLine(e);
}
catch (SystemException systemException)
{
if (IsLyncException(systemException))
{
// Log the exception thrown by the Lync Model API.
Console.WriteLine("Error: " + systemException);
}
else
{
// Rethrow the SystemException which did not come from the Lync Model API.
throw;
}
}
}
//https://blog.thoughtstuff.co.uk/2016/06/skypedevq-updating-skype-for-business-presence-client-sdk/
private void SkypeUpdateAvailability(ContactAvailability availability)
{
Dictionary <PublishableContactInformationType, object> newStatus = new Dictionary <PublishableContactInformationType, object>();
newStatus.Add(PublishableContactInformationType.Availability, availability);
skypeClient.Self.BeginPublishContactInformation(newStatus, skypeEndUpdate, skypeClient.Self);
}
public static string HumanReadable(this ContactAvailability c)
{
switch (c)
{
case ContactAvailability.Away:
return("Away");
case ContactAvailability.Busy:
return("Busy");
case ContactAvailability.BusyIdle:
return("Busy");
case ContactAvailability.DoNotDisturb:
return("Do Not Disturb");
case ContactAvailability.Free:
return("Available");
case ContactAvailability.FreeIdle:
return("Idle");
case ContactAvailability.None:
case ContactAvailability.Invalid:
case ContactAvailability.Offline:
return("Offline");
case ContactAvailability.TemporarilyAway:
return("Be Right Back");
default:
return("");
}
}
/// <summary>
/// Updates the user interface
/// </summary>
/// <param name="currentState"></param>
private void UpdateUserInterface(ClientState currentState)
{
//Update the client state in the user interface
clientStateTextBox.Text = currentState.ToString();
if (currentState == ClientState.SignedIn)
{
//Listen for events of changes of the contact's information
lyncClient.Self.Contact.ContactInformationChanged +=
new EventHandler<ContactInformationChangedEventArgs>(SelfContact_ContactInformationChanged);
//put email address who you want to monitor in format like sip:[email protected]
peer = lyncClient.ContactManager.GetContactByUri("");
peer.ContactInformationChanged += new EventHandler<ContactInformationChangedEventArgs>(PeerContact_ContactInformationChanged);
ContactAvailability pca = (ContactAvailability)peer.GetContactInformation(ContactInformationType.Availability);
if (pca == ContactAvailability.Away ||pca == ContactAvailability.Offline) { isAwayS = true; }
Console.WriteLine("S: " + pca + ",isAwayS: " + isAwayS);
//put email address who you want to monitor in format like sip:[email protected]
peer2 = lyncClient.ContactManager.GetContactByUri("");
peer2.ContactInformationChanged += new EventHandler<ContactInformationChangedEventArgs>(Peer2Contact_ContactInformationChanged);
pca = (ContactAvailability)peer2.GetContactInformation(ContactInformationType.Availability);
if (pca == ContactAvailability.Away) { isAwayM = true; }
Console.WriteLine("M: " + pca + ",isAwayM: " + isAwayM);
if (isAwayM && isAwayS)
{
Console.WriteLine("Both are away");
isAwayBoth = true;
//SendSMS("Both are away");
}
//Get the contact's information from Lync and update with it the corresponding elements of the user interface.
SetName();
SetAvailability();
SetPersonalNote();
SetContactPhoto();
//Update the SignInOut button content
signInOutButton.Content = "Sign Out";
//Enable elements in the user interface
personalNoteTextBox.IsEnabled = true;
availabilityComboBox.IsEnabled = true;
setNoteButton.IsEnabled = true;
}
else
{
//Update the SignInOut button content
signInOutButton.Content = "Sign In";
//Disable elements in the user interface
personalNoteTextBox.IsEnabled = false;
availabilityComboBox.IsEnabled = false;
setNoteButton.IsEnabled = false;
//Change the color of the border containing the contact's photo to match the contact's offline status
availabilityBorder.Background = Brushes.LightSlateGray;
}
}
private void Contact_ContactInformationChanged(object sender, ContactInformationChangedEventArgs e)
{
//Set LED matching Lync/SfB state
Console.WriteLine("Lync/SfB state changed!");
ContactAvailability myAvailability = (ContactAvailability)lyncClient.Self.Contact.GetContactInformation(ContactInformationType.Availability);
controlBusylight(string.Format("kSetLed,{0};", myAvailability.ToString()));
}
private static void DisplayContactPresence()
{
ContactAvailability myStatus = GetLyncAvailability();
Char myStatusChar = GetAvailabilityChar(myStatus);
Console.WriteLine("Status: " + myStatusChar);
SendSerialData(myStatusChar);
currentPresence = myStatus;
}
private void SetStatus(ContactAvailability availability, string personalNote)
{
var parameters = new Dictionary <PublishableContactInformationType, object>();
parameters.Add(PublishableContactInformationType.Availability, availability);
parameters.Add(PublishableContactInformationType.PersonalNote, personalNote);
_client.Self.BeginPublishContactInformation(parameters, BeginPublishContactInformationCallback, _client.Self);
}
private static void DisplayContactPresence()
{
ContactAvailability myStatus = GetLyncAvailability();
Char myStatusChar = GetAvailabilityChar(myStatus);
Console.WriteLine("Status: " + myStatusChar);
SendSerialData(myStatusChar);
currentPresence = myStatus;
}
/// <summary>
/// Read the current Availability Information from Lync/Skype for Business and set the color
/// </summary>
void SetCurrentContactState()
{
Rgb blinkColor = blinkColorOff;
byte[] arduinoLeds = arduinoColorOff;
if (lyncClient.State == ClientState.SignedIn)
{
ContactAvailability currentAvailability = (ContactAvailability)lyncClient.Self.Contact.GetContactInformation(ContactInformationType.Availability);
switch (currentAvailability)
{
case ContactAvailability.Busy: // Busy
blinkColor = blinkColorBusy;
arduinoLeds = arduinoColorBusy;
break;
case ContactAvailability.BusyIdle: // Busy and idle
blinkColor = blinkColorBusyIdle;
arduinoLeds = arduinoColorBusyIdle;
break;
case ContactAvailability.Free: // Available
blinkColor = blinkColorAvailable;
arduinoLeds = arduinoColorAvailable;
break;
case ContactAvailability.FreeIdle: // Available and idle
blinkColor = blinkColorAvailableIdle;
arduinoLeds = arduinoColorAvailableIdle;
break;
case ContactAvailability.Away: // Inactive/away, off work, appear away
case ContactAvailability.TemporarilyAway: // Be right back
blinkColor = blinkColorAway;
arduinoLeds = arduinoColorAway;
break;
case ContactAvailability.DoNotDisturb: // Do not disturb
blinkColor = blinkColorBusy;
arduinoLeds = arduinoColorBusy;
break;
case ContactAvailability.Offline: // Offline
blinkColor = blinkColorOff;
arduinoLeds = arduinoColorOff;
break;
default:
break;
}
SetBlink1State(blinkColor);
arduino.SetLEDs(arduinoLeds);
Debug.WriteLine(currentAvailability.ToString());
}
}
private void Lc_StateChanged(object sender, ClientStateChangedEventArgs e)
{
if (e.NewState == ClientState.SignedIn)
{
lc.Self.Contact.ContactInformationChanged += Contact_ContactInformationChanged;
ContactAvailability availability = (ContactAvailability)lc.Self.Contact.GetContactInformation(ContactInformationType.Availability);
ChangeColor(availability);
}
}
/// <summary>
/// lync search callback to parse the results of the query
/// </summary>
/// <param name="r"></param>
private void BeginSearchCallback(IAsyncResult r)
{
//Console.WriteLine("callback here");
object[] asyncState = (object[])r.AsyncState;
ContactManager cm = (ContactManager)asyncState[0];
try
{
SearchResults results = cm.EndSearch(r);
if (results.AllResults.Count == 0)
{
Console.WriteLine(Resources.NoResults);
_done = true;
}
else if (results.AllResults.Count == 1)
{
Contact contact = results.Contacts[0];
ContactAvailability availability = (ContactAvailability)contact.GetContactInformation(ContactInformationType.Availability);
//todo: check idle time without hanging
string timeElapsed = GetElapsedIdleTime(contact);
string userStatus = availability.ToString();
string statusCode = contact.GetContactInformation(ContactInformationType.Availability).ToString();
string isOutOfOfficeCheck = contact.GetContactInformation(ContactInformationType.IsOutOfOffice).ToString();
Console.WriteLine(String.Format("Status: {0}, Code: {1}, Last seen: {2}, Is Out Of Office: {3}", userStatus, statusCode, timeElapsed, isOutOfOfficeCheck));
//http://rcosic.wordpress.com/2011/11/17/availability-presence-in-lync-client/
//Invalid (-1),
//None (0) – Do not use this enumerator. This flag indicates that the cotact state is unspecified.,
//Free (3500) – A flag indicating that the contact is available,
//FreeIdle (5000) – Contact is free but inactive,
//Busy (6500) – A flag indicating that the contact is busy and inactive,
//BusyIdle (7500) – Contact is busy but inactive,
//DoNotDisturb (9500) – A flag indicating that the contact does not want to be disturbed,
//TemporarilyAway (12500) – A flag indicating that the contact is temporarily away,
//Away (15500) – A flag indicating that the contact is away,
//Offline (18500) – A flag indicating that the contact is signed out.
_done = true;
}
else
{
Console.WriteLine(Resources.MultipleResults);
_done = true;
}
}
catch (SearchException se)
{
Console.WriteLine(Resources.SearchFailed + se.Reason.ToString());
_done = true;
}
_client.ContactManager.EndSearch(r);
}
private bool CheckStatus(ContactAvailability availEnum)
{
foreach (ContactAvailability ca in _statusList)
{
if (ca == availEnum)
{
return(true);
}
}
return(false);
}
private ActionCommand CreateShowLedPanelActionCommand(ContactAvailability av)
{
var mapper = _ledPanelMapperFactory.Create(av);
var ledPanel = mapper.CreateLedPanel();
return(new ActionCommand()
{
WorkerMethodParameterValue = ledPanel,
WorkerMethod = LedDisplayWorkerConstants.METHOD_SHOWLEDPANEL,
WorkerName = LedDisplayWorkerConstants.NAME,
WorkerMethodParameterTypeName = nameof(VisualLedPanel)
});
}
internal LedPanelMapper Create(ContactAvailability ca)
{
var type = Assembly.GetExecutingAssembly().GetTypes().FirstOrDefault(f => typeof(LedPanelMapper).IsAssignableFrom(f) && f.Name == ca.ToString());
if (type == null)
{
throw new NotImplementedException(ca.ToString());
}
var result = (LedPanelMapper)Activator.CreateInstance(type);
return(result);
}
private static void SetPresence(ContactAvailability contactAvailability, string message = null)
{
try
{
lock (s_lyncClient_lock)
{
s_previousPresence = s_currentPresence;
s_currentPresence = contactAvailability;
//Check current Lync status
var lyncClientStatus =
(ContactAvailability)
s_lyncClient.Self.Contact.GetContactInformation(ContactInformationType.Availability);
if (s_previousPresence == lyncClientStatus)
{
//Updating
var newInformation = new Dictionary <PublishableContactInformationType, object>()
{
{ PublishableContactInformationType.Availability, contactAvailability },
{ PublishableContactInformationType.PersonalNote, message ?? string.Empty }
};
s_lyncClient.Self.BeginPublishContactInformation(newInformation, null, null);
}
else
{
//Lync status was changed by user, set state to free, we will wait until the user goes back to free before continuing
s_previousPresence = ContactAvailability.Free;
s_currentPresence = ContactAvailability.Free;
}
}
}
catch (Exception ex)
{
try
{
ShowWindow(s_handle, SW_SHOW);
Console.WriteLine(ex);
}
catch
{
// ignored
}
finally
{
//Deinitialize();
Initialize();
}
}
}
private static void UpdateSkypeAvilability()
{
try
{
if ((_lyncClient?.State == ClientState.SignedIn))
{
Status = ((ContactAvailability)_lyncClient.Self.Contact.GetContactInformation(ContactInformationType.Availability));
}
}
catch (Exception Ex)
{
Logger.Log(Ex.Message, Logger.LEVEL.ERROR);
}
}
/// <summary>
/// Send state to callback
/// </summary>
private void SendState()
{
if (callback == null)
{
return;
}
if (!sendEvent)
{
return;
}
if (lyncClient == null)
{
callback.WriteState("not-running", "");
return;
}
if (lyncClient.State != ClientState.SignedIn)
{
callback.WriteState("signed-out", "");
return;
}
foreach (var conv in lyncClient.ConversationManager.Conversations)
{
ModalityState state = conv.Modalities[ModalityTypes.AudioVideo].State;
if (state == ModalityState.Notified)
{
callback.WriteState("call-calling", "");
return;
}
if (state == ModalityState.Connecting ||
state == ModalityState.Connected ||
state == ModalityState.Joining ||
state == ModalityState.ConnectingToCaller)
{
callback.WriteState("call-connected", "");
return;
}
}
ContactAvailability currentAvailability = (ContactAvailability)lyncClient.Self.Contact.GetContactInformation(ContactInformationType.Availability);
// Busy, BusyIdle, Free, FreeIdle, Away, TemporarilyAway, DoNotDisturb, Offline
callback.WriteState(currentAvailability.ToString(), "");
}
/// <inheritdoc />
public void RunFor(ContactAvailability contactAvailability)
{
if (!Enum.IsDefined(typeof(ContactAvailability), contactAvailability))
{
throw new InvalidEnumArgumentException(nameof(contactAvailability), (int)contactAvailability, typeof(ContactAvailability));
}
_lyncClientInstance.Value.Self.BeginPublishContactInformation(new Dictionary <PublishableContactInformationType, object>
{
{
PublishableContactInformationType
.Availability,
contactAvailability
}
}, null, null);
}
private void setStatus(ContactAvailability newStatus)
{
try
{
var infoToPublish = new Dictionary <PublishableContactInformationType, object>();
infoToPublish.Add(PublishableContactInformationType.Availability, newStatus);
var theClient = LyncClient.GetClient();
var self = theClient.Self;
self.BeginPublishContactInformation(infoToPublish, EndPublishContactInformation, self);
}
catch
{
Console.WriteLine("Problem setting Skype for Business status. Is it running?");
}
}
public static void SetSelfAvailability(ContactAvailability availability, string activityId = null)
{
if (string.IsNullOrEmpty(activityId))
{
activityId = availability.ToString().ToLower();
}
try
{
var info = new Dictionary <PublishableContactInformationType, object> {
{ PublishableContactInformationType.Availability, availability },
{ PublishableContactInformationType.ActivityId, activityId }
};
LyncClient.GetClient().Self.BeginPublishContactInformation(info, null, null);
}
catch { }
}
private void Contact_ContactInformationChanged(object sender, ContactInformationChangedEventArgs e)
{
if (lc.State == ClientState.SigningOut || lc.State == ClientState.SignedOut || lc.State == ClientState.SigningIn)
{
LogitechGSDK.LogiLedRestoreLighting();
return;
}
Contact self = sender as Contact;
if (e.ChangedContactInformation.Contains(ContactInformationType.Availability))
{
ContactAvailability availability = (ContactAvailability)self.GetContactInformation(ContactInformationType.Availability);
ChangeColor(availability);
}
}
internal static me.ContactAvailability ToContactAvaliability(this ContactAvailability ca)
{
var nativeIndex = (int)ca;
var modelEnumType = typeof(me.ContactAvailability);
foreach (Enum val in Enum.GetValues(modelEnumType))
{
var fi = modelEnumType.GetField(val.ToString());
var custAttr = (NativeContactAvailabilityIdAttribute)fi.GetCustomAttributes(typeof(NativeContactAvailabilityIdAttribute), false).FirstOrDefault();
if (custAttr != null && custAttr.NativeIndex == nativeIndex)
{
return((me.ContactAvailability)val);
}
}
throw new NotImplementedException(ca.ToString());
}
private static char GetAvailabilityChar(ContactAvailability currentAvailability)
{
switch (currentAvailability)
{
case ContactAvailability.Free:
return 'a';
case ContactAvailability.Away:
return 'w';
case ContactAvailability.Busy:
return 'b';
case ContactAvailability.BusyIdle:
return 'b';
case ContactAvailability.DoNotDisturb:
return 'd';
case ContactAvailability.FreeIdle:
return 'a';
case ContactAvailability.TemporarilyAway:
return 'w';
case ContactAvailability.Offline:
return 'r';
default:
return 'r';
}
}
internal PresenceInformationEventArgs(ContactAvailability pState)
{
Presence = pState;
}
public void Set(ContactAvailability avail)
{
_cmdMessenger.SendCommand(new SendCommand((int)Command.SetLed, avail.ToString()));
}
private void OnPresenceChanged(ContactAvailability presence)
{
PresenceChanged(null, new PresenceInformationEventArgs(presence));
}
private void SetLyncAvailability(ContactAvailability availability)
{
Dictionary<PublishableContactInformationType, object> newInformation = new Dictionary<PublishableContactInformationType, object>();
newInformation.Add(PublishableContactInformationType.Availability, availability);
try
{
lyncClient.Self.BeginPublishContactInformation(newInformation, PublishContactInformationCallback, null);
}
catch (Exception ex)
{
statusTextBlock.Text = "ERROR: " + ex.Message;
}
}
public AvailabilityChangedEventArgs(ContactAvailability availability, string availabilityName)
{
this.Availability = availability;
this.AvailabilityName = availabilityName;
}
/// <summary>
/// 根据lync状态获取UC状态
/// </summary>
/// <param name="availability"></param>
/// <returns></returns>
UCContactAvailability GetUCState(ContactAvailability availability)
{
UCContactAvailability ucAvailability;
switch (availability)
{
case ContactAvailability.Free:
case ContactAvailability.FreeIdle:
ucAvailability = UCContactAvailability.Online;
break;
case ContactAvailability.Busy:
case ContactAvailability.BusyIdle:
ucAvailability = UCContactAvailability.Busy;
break;
case ContactAvailability.DoNotDisturb:
ucAvailability = UCContactAvailability.NoDisturb;
break;
case ContactAvailability.TemporarilyAway:
case ContactAvailability.Away:
ucAvailability = UCContactAvailability.Leave;
break;
default:
ucAvailability = UCContactAvailability.Offline;
break;
}
return ucAvailability;
}
/// <summary>
/// 获取lync状态
/// </summary>
public void GetLyncUserState()
{
if (_Client.Self.Contact == null)
{
userState = ContactAvailability.Free;
}
else
{
userState = (ContactAvailability)_Client.Self.Contact.GetContactInformation(ContactInformationType.Availability);//Get the current availability value from Lync
}
}
/// <summary>
/// Set the contact's current availability value from Lync
/// </summary>
public void SetAvailability(ContactAvailability state)
{
try
{
LogManager.SystemLog.Debug(string.Format("SetAvailability state = {0}", state));
//Add the availability to the contact information items to be published
Dictionary<PublishableContactInformationType, object> newInformation =
new Dictionary<PublishableContactInformationType, object>();
newInformation.Add(PublishableContactInformationType.Availability, state);
_Client.Self.BeginPublishContactInformation(newInformation, PublishContactInformationCallback, null);
UCContactAvailability ucAvailability = GetUCState(state);
LogInBusiness log = new LogInBusiness();
log.PubSelfStatus((int)ucAvailability, new StringBuilder());
}
catch (Exception ex)
{
LogManager.SystemLog.Error(ex.ToString());
}
}
public Availability(ContactAvailability contactAvailability, string availabilityName)
{
this.ContactAvailability = contactAvailability;
this.AvailabilityName = availabilityName;
}
/// <summary>
/// Update Lync status with new info, App => Lync
/// </summary>
/// <param name="message"></param>
/// <param name="location"></param>
/// <param name="availability"></param>
private void SetLyncStatus(string message, string location, ContactAvailability availability)
{
Dictionary<PublishableContactInformationType, object> newInformation = new Dictionary<PublishableContactInformationType, object>();
if (location != String.Empty)
newInformation.Add(PublishableContactInformationType.PersonalNote, message + " - " + location);
else
newInformation.Add(PublishableContactInformationType.PersonalNote, message);
newInformation.Add(PublishableContactInformationType.Availability, availability);
try
{
lyncClient.Self.BeginPublishContactInformation(newInformation, PublishContactInformationCallback, null);
}
catch (Exception ex)
{
statusTextBlock.Text = "ERROR: " + ex.Message;
}
}
