// </Snippet4>
//------------------------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------------------------
// <Snippet5>
// Enumerating all local registered applications.
private static void EnumLocalRegisteredApplications()
{
PeerApplicationCollection pac = null;
Console.WriteLine("Attempting to enumerate all local registered collaboration applications...");
try
{
pac = PeerCollaboration.GetLocalRegisteredApplications(PeerApplicationRegistrationType.AllUsers);
foreach (PeerApplication pa in pac)
{
Console.WriteLine("Registered application:\n ID: {0}\n Description: {1}\n", pa.Id, pa.Description);
}
}
catch (PeerToPeerException p2pEx)
{
Console.WriteLine("The Peer Collaboration Infrastructure could not return an enumeration of the registered applications: {0}",
p2pEx.Message);
}
catch (Exception ex)
{
Console.WriteLine("Unexpected exception caught when trying to enumerate the registered collaboration applications: {0}.",
ex.Message);
}
finally
{
foreach (PeerApplication pa in pac)
{
pa.Dispose();
}
}
return;
}
// </Snippet3>
//------------------------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------------------------
// <Snippet4>
// Registering Notepad.exe as a collab application with a fixed GUID.
// Note: If you're using the application to send invitations,
// the same application with the same GUID must be registered on the remote peer machine.
private static PeerApplication RegisterCollabApp()
{
PeerApplication application = null;
string pathToApp = "%SystemRoot%\\notepad.exe";
Guid appGuid = new Guid(0xAAAAAAAA, 0xFADE, 0xDEAF, 0xBE, 0xEF, 0xFF, 0xEE, 0xDD, 0xCC, 0xBB, 0xAE);
application = new PeerApplication();
application.Id = appGuid;
application.Path = pathToApp;
application.Description = "Peer Collaboration Sample -- notepad.exe";
application.PeerScope = PeerScope.All;
application.CommandLineArgs = "n";
application.Data = ASCIIEncoding.ASCII.GetBytes("Test");
Console.WriteLine("Attempting to register the application \"notepad.exe\"...");
try
{
PeerApplicationCollection pac = PeerCollaboration.GetLocalRegisteredApplications(PeerApplicationRegistrationType.AllUsers);
if (pac.Contains(application))
{
Console.WriteLine("The application is already registered on the peer.");
}
else
{
PeerCollaboration.RegisterApplication(application, PeerApplicationRegistrationType.AllUsers);
Console.WriteLine("Application registration succeeded!");
}
}
catch (ArgumentException argEx)
{
Console.WriteLine("The application was previously registered with the Peer Collaboration Infrastructure: {0}.", argEx.Message);
}
catch (PeerToPeerException p2pEx)
{
Console.WriteLine("The application failed to register with the Peer Collaboration Infrastructure: {0}", p2pEx.Message);
}
catch (Exception ex)
{
Console.WriteLine("An unexpected exception occurred when trying to register the application: {0}.", ex.Message);
}
return(application);
}
public static PeerApplicationCollection GetLocalRegisteredApplications(PeerApplicationRegistrationType type)
{
Logging.P2PTraceSource.TraceEvent(TraceEventType.Information, 0, "Entering GetLocalRegisteredApplications.");
PeerCollaborationPermission.UnrestrictedPeerCollaborationPermission.Demand();
if ((type < PeerApplicationRegistrationType.CurrentUser) || (type > PeerApplicationRegistrationType.AllUsers)){
throw new ArgumentOutOfRangeException("type");
}
CollaborationHelperFunctions.Initialize();
PeerApplicationCollection peerAppColl = new PeerApplicationCollection();
SafeCollabEnum handlePeerEnum = new SafeCollabEnum();
UInt32 appCount = 0;
int errorCode = 0;
//
// Enumerate and get all the registered applications from native
//
try{
errorCode = UnsafeCollabNativeMethods.PeerCollabEnumApplications(IntPtr.Zero, IntPtr.Zero, out handlePeerEnum);
if (errorCode != 0){
Logging.P2PTraceSource.TraceEvent(TraceEventType.Error, 0, "PeerCollabEnumApplications returned with errorcode {0}", errorCode);
throw (PeerToPeerException.CreateFromHr(SR.GetString(SR.Collab_GetLocalAppsFailed), errorCode));
}
errorCode = UnsafeCollabNativeMethods.PeerGetItemCount(handlePeerEnum, ref appCount);
if (errorCode != 0){
Logging.P2PTraceSource.TraceEvent(TraceEventType.Error, 0, "PeerGetItemCount returned with errorcode {0}", errorCode);
throw (PeerToPeerException.CreateFromHr(SR.GetString(SR.Collab_GetLocalAppsFailed), errorCode));
}
if (appCount == 0){
Logging.P2PTraceSource.TraceEvent(TraceEventType.Error, 0, "No local registered PeerApplications found.");
return peerAppColl;
}
unsafe{
SafeCollabData appArray = null;
try{
errorCode = UnsafeCollabNativeMethods.PeerGetNextItem(handlePeerEnum, ref appCount, out appArray);
if (errorCode != 0){
Logging.P2PTraceSource.TraceEvent(TraceEventType.Error, 0, "PeerGetNextItem returned with errorcode {0}", errorCode);
throw (PeerToPeerException.CreateFromHr(SR.GetString(SR.Collab_GetLocalAppsFailed), errorCode));
}
//
// Marshal each application from the array
//
IntPtr pPEER_APLICATION = appArray.DangerousGetHandle();
IntPtr* pApps = (IntPtr*)pPEER_APLICATION;
for (ulong i = 0; i < appCount; i++){
PEER_APPLICATION* pPeerApp = (PEER_APPLICATION*)pApps[i];
string description = Marshal.PtrToStringUni(pPeerApp->pwzDescription);
byte[] data = null;
if (pPeerApp->data.cbData != 0){
data = new byte[pPeerApp->data.cbData];
Marshal.Copy(pPeerApp->data.pbData, data, 0, (int)pPeerApp->data.cbData);
}
PeerApplication peerApp = new PeerApplication( CollaborationHelperFunctions.ConvertGUIDToGuid(pPeerApp->guid),
description, data, null, null, PeerScope.None);
peerAppColl.Add(peerApp);
}
}
finally{
appArray.Dispose();
}
}
}
finally{
handlePeerEnum.Dispose();
}
Logging.P2PTraceSource.TraceEvent(TraceEventType.Information, 0, "Got all local registered Applications. Start filtering");
PeerApplicationCollection peerAppCollFiltered = new PeerApplicationCollection();
//
// Filter the apps according to the Registration type the user wants
//
foreach (PeerApplication peerApplication in peerAppColl)
{
GUID guid = CollaborationHelperFunctions.ConvertGuidToGUID(peerApplication.Id);
SafeCollabData safeAppRegInfo = new SafeCollabData();
try{
errorCode = UnsafeCollabNativeMethods.PeerCollabGetApplicationRegistrationInfo(ref guid,
type,
out safeAppRegInfo);
if (errorCode != 0)
Logging.P2PTraceSource.TraceEvent(TraceEventType.Error, 0, "PeerCollabGetApplicationRegistrationInfo returned with errorcode {0}", errorCode);
if (!safeAppRegInfo.IsInvalid){
PEER_APPLICATION_REGISTRATION_INFO pari = (PEER_APPLICATION_REGISTRATION_INFO)
Marshal.PtrToStructure(safeAppRegInfo.DangerousGetHandle(),
typeof(PEER_APPLICATION_REGISTRATION_INFO));
peerApplication.Path = pari.pwzApplicationToLaunch;
peerApplication.CommandLineArgs = pari.pwzApplicationArguments;
peerApplication.PeerScope = (PeerScope)pari.dwPublicationScope;
peerAppCollFiltered.Add(peerApplication);
}
}
finally{
safeAppRegInfo.Dispose();
}
}
Logging.P2PTraceSource.TraceEvent(TraceEventType.Information, 0, "Filtering successful. Returning collection with {0} applications", peerAppCollFiltered.Count);
return peerAppCollFiltered;
}