public static CapabilityDiscoveryResult DiscoverCapability(this DiscoveryClient discoverClient, Capability capability)
{
return AsyncHelper.RunSync<CapabilityDiscoveryResult>(async () =>
{
return await discoverClient.DiscoverCapabilityAsync(capability);
});
}
public BlockBoolConstant()
{
width = 50;
height = 50;
Capability capability = new Capability(this);
capability.AddDataOutput("Constant", "bool");
UpdateConnectors();
}
public override string ToCommand(Capability capabilities)
{
if (!IsSupported(capabilities))
{
throw new NotSupportedException("The selected authentication mechanism is not supported");
}
return string.Format(ImapCommands.Authenticate + " {1}", "XOAUTH2", PrepareOAuthCredentials(Login, AuthToken));
}
public override string ToCommand(Capability capabilities)
{
if (!IsSupported(capabilities))
{
throw new NotSupportedException("The selected authentication mechanism is not supported");
}
return capabilities.LoginDisabled ? string.Format(ImapCommands.Authenticate + "\n{1}\n{2}", "PLAIN", Base64.ToBase64(Encoding.UTF8.GetBytes(Login)), Base64.ToBase64(Encoding.UTF8.GetBytes(Password))) : string.Format(ImapCommands.Login, Login, Password);
}
public void AddCapability(Capability capability) {
if (_enabledCapabilities.Contains(capability)) {
return;
}
var capImpl = _availableCapabilities[capability];
foreach (var dependency in capImpl.Dependencies) {
AddCapability(dependency);
}
_enabledCapabilities.Add(capability);
}
public XBeePin(string name, int pin, string atCommand, int atPin, Capability defaultCapability, string description, Capability[] capabilities)
{
Name = name;
Pin = pin;
AtCommand = atCommand;
AtPin = atPin;
Description = description;
DefaultCapability = defaultCapability;
Capabilities = capabilities;
}
private void TextureStatsHandler(Capability cap, IHttpClientContext context, IHttpRequest request, IHttpResponse response)
{
try
{
OSD osd = OSDParser.Deserialize(request.Body);
m_log.Info("Received a TextureStats message: " + osd.ToString());
}
catch (Exception)
{
m_log.Warn("Failed to decode TextureStats message");
}
}
internal static bool CheckCapability(DirectoryEntry rootDSE, Capability capability)
{
bool flag = false;
if (rootDSE != null)
{
if (capability != Capability.ActiveDirectory)
{
if (capability != Capability.ActiveDirectoryApplicationMode)
{
if (capability == Capability.ActiveDirectoryOrADAM)
{
foreach (string item in rootDSE.Properties[PropertyManager.SupportedCapabilities])
{
if (string.Compare(item, SupportedCapability.ADAMOid, StringComparison.OrdinalIgnoreCase) != 0 && string.Compare(item, SupportedCapability.ADOid, StringComparison.OrdinalIgnoreCase) != 0)
{
continue;
}
flag = true;
break;
}
}
}
else
{
foreach (string str in rootDSE.Properties[PropertyManager.SupportedCapabilities])
{
if (string.Compare(str, SupportedCapability.ADAMOid, StringComparison.OrdinalIgnoreCase) != 0)
{
continue;
}
flag = true;
break;
}
}
}
else
{
foreach (string item1 in rootDSE.Properties[PropertyManager.SupportedCapabilities])
{
if (string.Compare(item1, SupportedCapability.ADOid, StringComparison.OrdinalIgnoreCase) != 0)
{
continue;
}
flag = true;
break;
}
}
}
return flag;
}
private void ParcelVoiceInfoRequestHandler(Capability cap, IHttpClientContext context, IHttpRequest request, IHttpResponse response)
{
ParcelVoiceInfoRequestMessage message;
if (LLUtil.TryGetMessage<ParcelVoiceInfoRequestMessage>(request.Body, out message))
{
m_log.DebugFormat("ParcelVoiceInfoRequest: RegionName={0}, ParcelID={1}, SipChannelUri={2}",
message.RegionName, message.ParcelID, message.SipChannelUri);
}
else
{
m_log.Warn("Received invalid request data for ParcelVoiceInfoRequest");
response.Status = System.Net.HttpStatusCode.BadRequest;
}
}
public int MapInCapability(Thread current, Capability cap)
{
int id;
if (cap.parent == current)
{
id = cap.Uses.id;
cap.Uses.InsertAfter(Capabilities);
}
else
{
id = NewCapAllocId();
var cap_ref = new CapabilityRef(current, id, cap);
cap_ref.InsertAfter(Capabilities);
}
return id;
}
internal static bool CheckCapability(DirectoryEntry rootDSE, Capability capability)
{
bool flag = false;
if (rootDSE != null)
{
if (capability == Capability.ActiveDirectory)
{
foreach (string str in rootDSE.Properties[PropertyManager.SupportedCapabilities])
{
if (string.Compare(str, SupportedCapability.ADOid, StringComparison.OrdinalIgnoreCase) == 0)
{
return true;
}
}
return flag;
}
if (capability == Capability.ActiveDirectoryApplicationMode)
{
foreach (string str2 in rootDSE.Properties[PropertyManager.SupportedCapabilities])
{
if (string.Compare(str2, SupportedCapability.ADAMOid, StringComparison.OrdinalIgnoreCase) == 0)
{
return true;
}
}
return flag;
}
if (capability != Capability.ActiveDirectoryOrADAM)
{
return flag;
}
foreach (string str3 in rootDSE.Properties[PropertyManager.SupportedCapabilities])
{
if ((string.Compare(str3, SupportedCapability.ADAMOid, StringComparison.OrdinalIgnoreCase) == 0) || (string.Compare(str3, SupportedCapability.ADOid, StringComparison.OrdinalIgnoreCase) == 0))
{
return true;
}
}
}
return flag;
}
public override bool IsSupported(Capability capabilities)
{
return(capabilities != null && (!capabilities.LoginDisabled || capabilities.AuthenticationMechanisms.Contains("PLAIN")));
}
private bool NegotiateArea(ScanSettings scanSettings)
{
var area = scanSettings.Area;
if (area == null)
{
return false;
}
var cap = new Capability(Capabilities.IUnits, TwainType.Int16, _applicationId, SourceId);
if ((Units)cap.GetBasicValue().Int16Value != area.Units)
{
Capability.SetCapability(Capabilities.IUnits, (short)area.Units, _applicationId, SourceId);
}
var imageLayout = new ImageLayout
{
Frame = new Frame
{
Left = new Fix32(area.Left),
Top = new Fix32(area.Top),
Right = new Fix32(area.Right),
Bottom = new Fix32(area.Bottom)
}
};
var result = Twain32Native.DsImageLayout(
_applicationId,
SourceId,
DataGroup.Image,
DataArgumentType.ImageLayout,
Message.Set,
imageLayout);
if (result != TwainResult.Success)
{
throw new TwainException("DsImageLayout.GetDefault error", result);
}
return true;
}
public void NegotiateOrientation(ScanSettings scanSettings)
{
// Set orientation (default is portrait)
var cap = new Capability(Capabilities.Orientation, TwainType.Int16, _applicationId, SourceId);
if ((Orientation)cap.GetBasicValue().Int16Value != Orientation.Default)
{
Capability.SetBasicCapability(Capabilities.Orientation, (ushort)scanSettings.Page.Orientation, TwainType.UInt16, _applicationId, SourceId);
}
}
public static async Task <CapabilityDiscoveryResult> DiscoverCapabilityAsync(this DiscoveryClient discoveryClient, Capability capability)
{
return(await discoveryClient.DiscoverCapabilityAsync(capability.ToString()));
}
private void UploadObjectAssetHandler(Capability cap, IHttpClientContext context, IHttpRequest request, IHttpResponse response)
{
UploadObjectAssetMessage message;
if (LLUtil.TryGetMessage<UploadObjectAssetMessage>(request.Body, out message))
{
LLPrimitive parent = null;
// Build the linkset
for (int i = 0; i < message.Objects.Length; i++)
{
UploadObjectAssetMessage.Object obj = message.Objects[i];
#region Primitive Creation
Primitive prim = new Primitive();
prim.Properties = new Primitive.ObjectProperties();
prim.Sculpt = new Primitive.SculptData();
prim.Textures = new Primitive.TextureEntry(UUID.Zero);
prim.Flags = PrimFlags.CastShadows | PrimFlags.InventoryEmpty | PrimFlags.CreateSelected;
prim.ID = UUID.Random();
prim.MediaURL = String.Empty;
prim.OwnerID = cap.OwnerID;
prim.GroupID = obj.GroupID;
prim.TextColor = Color4.Black;
prim.Properties.CreationDate = DateTime.UtcNow;
prim.Properties.CreatorID = cap.OwnerID;
prim.Properties.Description = String.Empty;
prim.Properties.GroupID = obj.GroupID;
prim.Properties.LastOwnerID = cap.OwnerID;
prim.Properties.Name = obj.Name;
prim.Properties.ObjectID = prim.ID;
prim.Properties.OwnerID = prim.OwnerID;
prim.Properties.Permissions = (m_permissions != null) ?
m_permissions.GetDefaultPermissions() :
Permissions.FullPermissions;
prim.Properties.SalePrice = 10;
prim.PrimData.PCode = PCode.Prim;
prim.PrimData.Material = obj.Material;
prim.PrimData.PathBegin = obj.PathBegin;
prim.PrimData.PathCurve = (PathCurve)obj.PathCurve;
prim.PrimData.PathEnd = obj.PathEnd;
prim.PrimData.ProfileBegin = obj.ProfileBegin;
prim.PrimData.ProfileCurve = (ProfileCurve)obj.ProfileCurve;
prim.PrimData.ProfileEnd = obj.ProfileEnd;
prim.PrimData.ProfileHollow = obj.ProfileHollow;
prim.PrimData.PathRadiusOffset = obj.RadiusOffset;
prim.PrimData.PathRevolutions = obj.Revolutions;
prim.PrimData.PathScaleX = obj.ScaleX;
prim.PrimData.PathScaleY = obj.ScaleY;
prim.PrimData.PathShearX = obj.ShearX;
prim.PrimData.PathShearY = obj.ShearY;
prim.PrimData.PathSkew = obj.Skew;
prim.PrimData.PathTaperX = obj.TaperX;
prim.PrimData.PathTaperY = obj.TaperY;
prim.PrimData.PathTwist = obj.Twist;
prim.PrimData.PathTwistBegin = obj.TwistBegin;
// Extra parameters
for (int j = 0; j < obj.ExtraParams.Length; j++)
{
UploadObjectAssetMessage.Object.ExtraParam extraParam = obj.ExtraParams[j];
switch (extraParam.Type)
{
case ExtraParamType.Flexible:
prim.Flexible = new Primitive.FlexibleData(extraParam.ExtraParamData, 0);
break;
case ExtraParamType.Light:
prim.Light = new Primitive.LightData(extraParam.ExtraParamData, 0);
break;
case ExtraParamType.Sculpt:
prim.Sculpt = new Primitive.SculptData(extraParam.ExtraParamData, 0);
break;
}
}
// Faces
for (int j = 0; j < obj.Faces.Length; j++)
{
UploadObjectAssetMessage.Object.Face face = obj.Faces[j];
Primitive.TextureEntryFace primFace = prim.Textures.GetFace(0);
primFace.Bump = face.Bump;
primFace.RGBA = face.Color;
primFace.Fullbright = face.Fullbright;
primFace.Glow = face.Glow;
primFace.TextureID = face.ImageID;
primFace.Rotation = face.ImageRot;
primFace.MediaFlags = ((face.MediaFlags & MEDIA_MASK) != 0);
primFace.OffsetU = face.OffsetS;
primFace.OffsetV = face.OffsetT;
primFace.RepeatU = face.ScaleS;
primFace.RepeatV = face.ScaleT;
primFace.TexMapType = (MappingType)(face.MediaFlags & TEX_MAP_MASK);
}
prim.Sculpt.SculptTexture = obj.SculptID;
prim.Sculpt.Type = obj.SculptType;
#endregion Primitive Creation
LLPrimitive llprim = new LLPrimitive(prim, m_scene, m_primMesher);
llprim.Scale = obj.Scale;
// Link children prims to the parent
if (i == 0)
{
llprim.RelativePosition = obj.Position;
llprim.RelativeRotation = obj.Rotation;
m_scene.EntityAddOrUpdate(this, llprim, UpdateFlags.FullUpdate, 0);
parent = llprim;
}
else
{
llprim.RelativePosition = obj.Position;
llprim.RelativeRotation = obj.Rotation;
llprim.SetParent(parent, true, false);
m_scene.EntityAddOrUpdate(this, llprim, UpdateFlags.FullUpdate, 0);
}
}
}
else
{
m_log.Warn("Received invalid data for UploadObjectAsset");
response.Status = System.Net.HttpStatusCode.BadRequest;
}
}
public override bool HasAvailableCapability(Capability capability) => false;
public static CapabilityDiscoveryResult DiscoverCapability(this DiscoveryClient discoverClient, Capability capability)
{
return(AsyncHelper.RunSync <CapabilityDiscoveryResult>(async() =>
{
return await discoverClient.DiscoverCapabilityAsync(capability);
}));
}
public override void AddSupportedCapability(Capability capability)
{
}
public AgnosticListenerTest(ITestOutputHelper _log)
{
Assert.True(Capability.IPv4Support() && Capability.IPv6Support());
}
public WMAppManifest()
{
// parse the xml manifest once
// parse the package xml to get attributes
XmlReader xr = XmlReader.Create("WMAppManifest.xml");
if (xr.ReadToDescendant("Deployment"))
{
// if built as an 8.1 app defer to platform for most properties
IsSilverlight81 = new Version(xr["AppPlatformVersion"]) > new Version(8, 0);
if (xr.ReadToDescendant("App"))
{
ProductID = xr["ProductID"];
DisplayName = xr["Title"];
Description = xr["Description"];
if (DisplayName.StartsWith("@"))
{
try
{
object[] attributes = Assembly.Load(Deployment.Current.EntryPointAssembly).GetCustomAttributes(typeof(AssemblyProductAttribute), false);
if (attributes.Length > 0)
{
AssemblyProductAttribute productAttribute = attributes[0] as AssemblyProductAttribute;
if (productAttribute != null)
{
DisplayName = productAttribute.Product;
}
}
}
catch
{
// will fail from background task
}
}
Version = new Version(xr["Version"]).ToPackageVersion();
PublisherDisplayName = xr["Publisher"];
PublisherId = xr["PublisherID"];
if (xr.ReadToDescendant("IconPath"))
{
Logo = ImagePathToUri(xr);
}
if (xr.ReadToFollowing("Capabilities"))
{
bool more = xr.ReadToDescendant("Capability");
while (more)
{
Capability newCapability = (Capability)0;
DeviceCapability newDeviceCapability = (DeviceCapability)0;
switch (xr["Name"])
{
case "ID_CAP_NETWORKING":
newCapability = Capability.Internet;
break;
/*case "ID_CAP_IDENTITY_DEVICE":
* newCapability = Capability.IdentityDevice;
* break;
* case "ID_CAP_IDENTITY_USER":
* newCapability = Capability.IdentityUser;
* break;
* case "ID_FUNCCAP_EXTEND_MEM":
* newCapability = Capability.ExtendedMemory;
* break;*/
case "ID_CAP_LOCATION":
newDeviceCapability = DeviceCapability.Location;
break;
case "ID_CAP_SENSORS":
newDeviceCapability = DeviceCapability.Sensors;
break;
case "ID_CAP_MICROPHONE":
newDeviceCapability = DeviceCapability.Microphone;
break;
//case "ID_CAP_MEDIALIB":
// newCapability = Capability.MediaLibrary;
// break;
case "ID_CAP_MEDIALIB_AUDIO":
newCapability = Capability.Music;
break;
case "ID_CAP_MEDIALIB_PHOTO":
newCapability = Capability.Pictures;
break;
/*case "ID_CAP_MEDIALIB_PLAYBACK":
* newCapability = Capability.MusicLibraryPlayback;
* break;
* case "ID_CAP_GAMERSERVICES":
* newCapability = Capability.GamerServices;
* break;*/
case "ID_CAP_PHONEDIALER":
newCapability = Capability.PhoneDialer;
break;
case "ID_CAP_PUSH_NOTIFICATION":
newCapability = Capability.PushNotification;
break;
case "ID_CAP_REMOVABLE_STORAGE":
newCapability = Capability.RemovableStorage;
break;
/*case "ID_CAP_WEBBROWSERCOMPONENT":
* newCapability = Capability.WebBrowserComponent;
* break;
* case "ID_CAP_RINGTONE_ADD":
* newCapability = Capability.RingtoneAdd;
* break;*/
case "ID_CAP_PROXIMITY":
newDeviceCapability = DeviceCapability.Proximity;
break;
case "ID_CAP_SPEECH_RECOGNITION":
newCapability = Capability.SpeechRecognition;
break;
case "ID_CAP_VOIP":
newCapability = Capability.Voip;
break;
case "ID_CAP_WALLET":
newCapability = Capability.Wallet;
break;
/*case "ID_CAP_WALLET_PAYMENTINSTRUMENTS":
* newCapability = Capability.WalletPaymentInstruments;
* break;
* case "ID_CAP_WALLET_SECUREELEMENT":
* newCapability = Capability.WalletSecureElement;
* break;*/
case "ID_CAP_APPOINTMENTS":
newCapability = Capability.Appointments;
break;
case "ID_CAP_CONTACTS":
newCapability = Capability.Contacts;
break;
case "ID_CAP_ISV_CAMERA":
newDeviceCapability = DeviceCapability.Camera;
break;
}
global::System.Diagnostics.Debug.WriteLine((int)newCapability);
Capabilities |= newCapability;
DeviceCapabilities |= newDeviceCapability;
more = xr.ReadToNextSibling("Capability");
}
}
}
}
xr.Dispose();
}
public void AddCapability(Capability capability)
{
_capabilities.Add(capability);
}
public static extern int XInputGetCapabilities
(
int dwUserIndex, // [in] Index of the gamer associated with the device
int dwFlags, // [in] Input flags that identify the device type
ref Capability pCapabilities // [out] Receives the capabilities
);
public DisconnectTest(ITestOutputHelper output)
{
_log = TestLogging.GetInstance();
Assert.True(Capability.IPv4Support() || Capability.IPv6Support());
}
private void NewFileAgentInventoryVariablePriceHandler(Capability cap, IHttpClientContext context, IHttpRequest request, IHttpResponse response)
{
NewFileAgentInventoryVariablePriceMessage message;
if (LLUtil.TryGetMessage<NewFileAgentInventoryVariablePriceMessage>(request.Body, out message))
{
NewFileAgentInventoryVariablePriceReplyMessage reply = new NewFileAgentInventoryVariablePriceReplyMessage();
reply.ResourceCost = 0;
reply.UploadPrice = 0;
// Create a one time upload capability
reply.Rsvp = m_scene.Capabilities.AddOneTimeCapability(cap.OwnerID, true,
delegate(Capability _cap, IHttpClientContext _context, IHttpRequest _request, IHttpResponse _response)
{ NewFileAgentInventoryVariablePriceUploadHandler(message, _cap, _context, _request, _response); }
);
LLUtil.SendLLSDXMLResponse(response, reply.Serialize());
}
else
{
m_log.Warn("Received invalid data for NewFileAgentInventoryVariablePrice");
response.Status = System.Net.HttpStatusCode.BadRequest;
}
}
public override bool IsSupported(Capability capabilities)
{
return capabilities != null && (!capabilities.LoginDisabled || capabilities.AuthenticationMechanisms.Contains("PLAIN"));
}
public void BasicTest_StaticIPv6LoopbackIndex_ExceptionIfV6NotSupported()
{
Assert.True(Capability.IPv6Support());
_log.WriteLine("Loopback IPv6 index: " + NetworkInterface.IPv6LoopbackInterfaceIndex);
}
public BlockBoolInvert()
{
width = 100;
height = 50;
Capability capability = new Capability(this);
capability.AddDataInput("", "bool");
capability.AddDataOutput("", "bool");
UpdateConnectors();
Name = "Invert";
}
public BlockGenericEvent()
{
width = 100;
height = 50;
Capability capability = new Capability(this);
capability.AddTriggerOutput("");
UpdateConnectors();
}
private static byte[] GetPingPayload(AddressFamily addressFamily)
// On Unix, Non-root processes cannot send arbitrary data in the ping packet payload
=> Capability.CanUseRawSockets(addressFamily) || PlatformDetection.IsOSXLike
? TestSettings.PayloadAsBytes
: Array.Empty <byte>();
public BlockSetDebugLed()
{
width = 100;
height = 50;
Capability capability = new Capability(this);
capability.AddDataInput("State", "bool");
capability.AddTriggerInput("");
UpdateConnectors();
Name = "Set Debug LED";
}
protected async Task RequestNamesViaCapability(Capability cap)
{
if (cap.CapabilityType != CapabilityType.Http)
{
Logger.LogWarning($"AvatarNameCache: GetDisplayName capability not of type HTTP. ({cap.CapabilityType})");
return;
}
string url = "";
lock (PendingRequests)
{
bool first = true;
foreach (Request request in PendingRequests.Where(x => x.Value.IsRequested == false).Select(x => x.Value))
{
if (url.Length >= NAME_URL_SEND_THRESHOLD)
{
break;
}
url += $"{(first ? "?" : "&")}ids={request.AgentId.ToString()}";
request.IsRequested = true;
first = false;
}
}
if (url == "")
{
return;
}
url = $"{cap.Url}/{url}";
try
{
HttpWebRequest request = WebRequest.CreateHttp(url);
request.ServerCertificateValidationCallback = (sender, certificate, chain, errors) => true;
request.Method = "GET";
var response = (HttpWebResponse)await request.GetResponseAsync();
if (response.StatusCode != HttpStatusCode.OK)
{
throw new Exception($"WARN AvatarNameCache.RequestNamesViaCapability: Get failed with return code {response.StatusCode}.");
}
int length = (int)response.ContentLength;
var contentStream = response.GetResponseStream();
if (contentStream == null)
{
throw new Exception($"AvatarNameCache.RequestNamesViaCapability: Failed to get response stream.");
}
var buffer = new byte[length];
try
{
int count = 0;
int start = 0;
while ((count = await contentStream.ReadAsync(buffer, start, length - start)) != 0)
{
start += count;
}
}
catch (IOException ex)
{
if (!ex.Message.StartsWith("The response ended prematurely"))
{
throw;
}
}
string responseText = Encoding.UTF8.GetString(buffer).Replace("\0", "");
XmlDocument document = new XmlDocument();
document.Load(new StringReader(responseText));
ProcessResponse(document);
}
catch (Exception e)
{
Logger.LogWarning($"AvatarNameCache.RequestNamesViaCapability: Exception {e}");
}
}
public void Create()
{
Capabilities.Clear();
width = 100;
height = 50;
ProductDataBase.Device device = ProductDataBase.GetDeviceByID(DeviceType);
if (device != null)
{
Capability capability = new Capability(this);
ProductDataBase.Device.RemoteEvent evnt = device.GetRemoteEventByID(EventID);
if (evnt != null)
{
foreach (ProductDataBase.Device.RemoteEvent.Output o in evnt.Outputs)
{
capability.AddDataOutput(o.Name, o.Type);
}
foreach (ProductDataBase.Device.RemoteEvent.Input i in evnt.Inputs)
{
if (i.Type == "void")
capability.AddTriggerInput(i.Name);
else
capability.AddDataInput(i.Name, i.Type);
}
if (capability.TriggerInputs.Count == 0 && (capability.TriggerInputs.Count != 0 || capability.DataOutputs.Count == 0))
{
capability.AddTriggerInput("Trigger");
}
}
}
UpdateConnectors();
}
private void ProvisionVoiceAccountRequestHandler(Capability cap, IHttpClientContext context, IHttpRequest request, IHttpResponse response)
{
ProvisionVoiceAccountRequestMessage reply = new ProvisionVoiceAccountRequestMessage();
reply.Username = String.Empty;
reply.Password = String.Empty;
// TODO: Implement this once we have Freeswitch support
//LLUtil.SendLLSDXMLResponse(response, reply.Serialize());
}
public override bool HasAgreedCapability(Capability capability) => false;
/// <summary>
/// Negotiates the size of the page.
/// </summary>
/// <param name="scanSettings">The scan settings.</param>
public void NegotiatePageSize(ScanSettings scanSettings)
{
var cap = new Capability(Capabilities.Supportedsizes, TwainType.Int16, _applicationId, SourceId);
if ((PageType)cap.GetBasicValue().Int16Value != PageType.UsLetter)
{
Capability.SetBasicCapability(Capabilities.Supportedsizes, (ushort)scanSettings.Page.Size, TwainType.UInt16, _applicationId, SourceId);
}
}
private void NewFileAgentInventoryHandler(Capability cap, IHttpClientContext context, IHttpRequest request, IHttpResponse response)
{
NewFileAgentInventoryMessage message;
if (LLUtil.TryGetMessage<NewFileAgentInventoryMessage>(request.Body, out message))
{
m_log.Error("Implement NewFileAgentInventory");
}
else
{
m_log.Warn("Received invalid data for NewFileAgentInventory");
response.Status = System.Net.HttpStatusCode.BadRequest;
}
}
private void ObjectMediaHandler(Capability cap, IHttpClientContext context, IHttpRequest request, IHttpResponse response)
{
ObjectMediaMessage message;
if (LLUtil.TryGetMessage <ObjectMediaMessage>(request.Body, out message))
{
if (message.Request is ObjectMediaRequest)
{
ObjectMediaRequest mediaRequest = (ObjectMediaRequest)message.Request;
ISceneEntity entity;
if (m_scene.TryGetEntity(mediaRequest.PrimID, out entity) && entity is LLPrimitive)
{
LLPrimitive prim = (LLPrimitive)entity;
ObjectMediaResponse reply = new ObjectMediaResponse();
reply.PrimID = prim.ID;
reply.FaceMedia = prim.Prim.FaceMedia ?? new MediaEntry[0];
reply.Version = prim.Prim.MediaVersion ?? String.Empty;
LLUtil.SendLLSDXMLResponse(response, reply.Serialize());
}
else
{
m_log.Warn("Received an ObjectMedia request for unknown prim " + mediaRequest.PrimID);
}
}
else if (message.Request is ObjectMediaUpdate)
{
ObjectMediaUpdate update = (ObjectMediaUpdate)message.Request;
ISceneEntity entity;
if (m_scene.TryGetEntity(update.PrimID, out entity) && entity is LLPrimitive)
{
LLPrimitive prim = (LLPrimitive)entity;
int lastVersion = ParseMediaVersion(prim.Prim.MediaVersion);
prim.Prim.FaceMedia = update.FaceMedia;
prim.Prim.MediaVersion = CreateMediaVersion(lastVersion + 1, cap.OwnerID);
// Set the CurrentURL fields
for (int i = 0; i < prim.Prim.FaceMedia.Length; i++)
{
MediaEntry entry = prim.Prim.FaceMedia[i];
if (entry != null && String.IsNullOrEmpty(entry.CurrentURL))
{
entry.CurrentURL = entry.HomeURL;
}
}
// Set the texture face media flags
for (int i = 0; i < prim.Prim.Textures.FaceTextures.Length; i++)
{
Primitive.TextureEntryFace face = prim.Prim.Textures.FaceTextures[i];
MediaEntry entry = (update.FaceMedia.Length > i) ? update.FaceMedia[i] : null;
if (entry != null)
{
if (face == null)
{
face = prim.Prim.Textures.CreateFace((uint)i);
}
face.MediaFlags = true;
}
else if (face != null)
{
face.MediaFlags = false;
}
}
m_scene.EntityAddOrUpdate(this, prim, UpdateFlags.FullUpdate, 0);
}
else
{
m_log.Warn("Could not update ObjectMedia for " + update.PrimID + ", prim not found");
}
}
else
{
m_log.Warn("Unrecognized ObjectMedia message: " + message.Request);
}
}
else
{
m_log.Warn("Received invalid data for ObjectMedia");
response.Status = System.Net.HttpStatusCode.BadRequest;
}
}
public override bool IsSupported(Capability capabilities)
{
return(capabilities.XoAuth2);
}
public BlockDelay()
{
width = 100;
height = 50;
Capability capability = new Capability(this);
capability.AddTriggerOutput("");
capability.AddTriggerInput("Reset");
capability.AddDataInput("Delay", "int");
UpdateConnectors();
}
public static Capability <string> FromPostViewSize(Capability <string> info)
{
return(AsDisplayNames <string>(info, FromPostViewSize));
}
public BlockIntConstant()
{
width = 50;
height = 50;
Capability capability = new Capability(this);
capability.AddDataOutput("", "int");
UpdateConnectors();
Name = "Constant";
}
public static Capability <string> FromViewAngle(Capability <int> info)
{
return(AsDisplayNames <int>(info, FromViewAngle));
}
public void Create()
{
Capabilities.Clear();
width = 100;
height = 50;
ProductDataBase.Device device = ProductDataBase.GetDeviceByID(DeviceType);
if (device != null)
{
ProductDataBase.Device.Event evnt = device.GetEventByID(EventID);
if (evnt != null)
{
Capability capability = new Capability(this);
capability.AddTriggerOutput("Trigger");
foreach (ProductDataBase.Device.Event.Output o in evnt.Outputs)
{
capability.AddDataOutput(o.Name, o.Type);
}
}
}
UpdateConnectors();
}
public static Capability <string> FromMovieQuality(Capability <string> info)
{
return(AsDisplayNames <string>(info, FromMovieQuality));
}
public CapabilityRequestMessage(Capability capability)
{
Capabilities = new[] {capability.Name};
}
public static Capability <string> FromStillImageSize(Capability <StillImageSize> info)
{
return(AsDisplayNames <StillImageSize>(info, FromStillImageSize));
}
private void ViewerStatsHandler(Capability cap, IHttpClientContext context, IHttpRequest request, IHttpResponse response)
{
ViewerStatsMessage message;
if (LLUtil.TryGetMessage<ViewerStatsMessage>(request.Body, out message))
{
DateTime timestamp = DateTime.UtcNow;
if (m_statsTracker != null)
{
// Log timestamped data points
m_statsTracker.LogEntry(timestamp, message.SessionID, "AgentFPS", message.AgentFPS);
m_statsTracker.LogEntry(timestamp, message.SessionID, "AgentMemoryUsed", message.AgentMemoryUsed);
m_statsTracker.LogEntry(timestamp, message.SessionID, "AgentPing", message.AgentPing);
m_statsTracker.LogEntry(timestamp, message.SessionID, "AgentsInView", message.AgentsInView);
m_statsTracker.LogEntry(timestamp, message.SessionID, "FailuresInvalid", message.FailuresInvalid);
m_statsTracker.LogEntry(timestamp, message.SessionID, "FailuresOffCircuit", message.FailuresOffCircuit);
m_statsTracker.LogEntry(timestamp, message.SessionID, "FailuresResent", message.FailuresResent);
m_statsTracker.LogEntry(timestamp, message.SessionID, "FailuresSendPacket", message.FailuresSendPacket);
m_statsTracker.LogEntry(timestamp, message.SessionID, "InCompressedPackets", message.InCompressedPackets);
m_statsTracker.LogEntry(timestamp, message.SessionID, "InKbytes", message.InKbytes);
m_statsTracker.LogEntry(timestamp, message.SessionID, "InPackets", message.InPackets);
m_statsTracker.LogEntry(timestamp, message.SessionID, "InSavings", message.InSavings);
m_statsTracker.LogEntry(timestamp, message.SessionID, "MetersTraveled", message.MetersTraveled);
m_statsTracker.LogEntry(timestamp, message.SessionID, "MiscInt1", message.MiscInt1);
m_statsTracker.LogEntry(timestamp, message.SessionID, "MiscInt2", message.MiscInt2);
m_statsTracker.LogEntry(timestamp, message.SessionID, "MiscString1", message.MiscString1);
m_statsTracker.LogEntry(timestamp, message.SessionID, "MiscVersion", message.MiscVersion);
m_statsTracker.LogEntry(timestamp, message.SessionID, "ObjectKbytes", message.object_kbytes);
m_statsTracker.LogEntry(timestamp, message.SessionID, "OutCompressedPackets", message.OutCompressedPackets);
m_statsTracker.LogEntry(timestamp, message.SessionID, "OutKbytes", message.OutKbytes);
m_statsTracker.LogEntry(timestamp, message.SessionID, "OutPackets", message.OutPackets);
m_statsTracker.LogEntry(timestamp, message.SessionID, "OutSavings", message.OutSavings);
m_statsTracker.LogEntry(timestamp, message.SessionID, "RegionsVisisted", message.RegionsVisited);
m_statsTracker.LogEntry(timestamp, message.SessionID, "SimulatorFPS", message.SimulatorFPS);
m_statsTracker.LogEntry(timestamp, message.SessionID, "StatsDropped", message.StatsDropped);
m_statsTracker.LogEntry(timestamp, message.SessionID, "StatsFailedResends", message.StatsFailedResends);
m_statsTracker.LogEntry(timestamp, message.SessionID, "TextureKbytes", message.texture_kbytes);
m_statsTracker.LogEntry(timestamp, message.SessionID, "WorldKbytes", message.world_kbytes);
// Update constant values for this session
m_statsTracker.SetValue(message.SessionID, "AgentLanguage", message.AgentLanguage);
m_statsTracker.SetValue(message.SessionID, "AgentRuntime", message.AgentRuntime);
m_statsTracker.SetValue(message.SessionID, "AgentStartTime", message.AgentStartTime);
m_statsTracker.SetValue(message.SessionID, "AgentVersion", message.AgentVersion);
m_statsTracker.SetValue(message.SessionID, "SystemCPU", message.SystemCPU);
m_statsTracker.SetValue(message.SessionID, "SystemGPU", message.SystemGPU);
m_statsTracker.SetValue(message.SessionID, "SystemGPUClass", message.SystemGPUClass);
m_statsTracker.SetValue(message.SessionID, "SystemGPUVendor", message.SystemGPUVendor);
m_statsTracker.SetValue(message.SessionID, "SystemGPUVersion", message.SystemGPUVersion);
m_statsTracker.SetValue(message.SessionID, "SystemInstalledRam", message.SystemInstalledRam);
m_statsTracker.SetValue(message.SessionID, "SystemOS", message.SystemOS);
m_statsTracker.SetValue(message.SessionID, "VertexBuffersEnabled", message.VertexBuffersEnabled);
}
}
else
{
m_log.Warn("Received invalid data for ViewerStats");
response.Status = System.Net.HttpStatusCode.BadRequest;
}
}
public static Capability <string> FromWhiteBalance(Capability <string> info)
{
return(AsDisplayNames <string>(info, FromWhiteBalance));
}
private void NewFileAgentInventoryUploadHandler(NewFileAgentInventoryMessage message, Capability cap,
IHttpClientContext context, IHttpRequest request, IHttpResponse response)
{
byte[] assetData = request.GetBody();
UUID assetID = UUID.Zero;
UUID itemID = UUID.Zero;
m_log.Debug("Received inventory asset upload from " + cap.OwnerID + " (" + assetData.Length + " bytes)");
if (assetData != null && assetData.Length > 0)
{
string contentType = LLUtil.LLAssetTypeToContentType((int)message.AssetType);
// Create the asset
if (m_assetClient.StoreAsset(contentType, false, false, assetData, cap.OwnerID, out assetID))
{
// Create the inventory item
LLInventoryItem item = new LLInventoryItem();
item.AssetID = assetID;
item.ContentType = contentType;
item.CreationDate = DateTime.UtcNow;
item.CreatorID = cap.OwnerID;
item.Description = message.Description;
item.ID = UUID.Random();
item.Name = message.Name;
item.OwnerID = cap.OwnerID;
item.ParentID = message.FolderID;
item.Permissions = (m_permissions != null) ? m_permissions.GetDefaultPermissions() : Permissions.FullPermissions;
item.SalePrice = 10;
item.SaleType = SaleType.Not;
if (m_inventoryClient.TryCreateItem(cap.OwnerID, item))
itemID = item.ID;
else
m_log.Warn("Failed to create inventory item for uploaded asset " + assetID);
}
else
{
m_log.WarnFormat("Failed to store uploaded inventory asset ({0} bytes)", assetData.Length);
}
}
else
{
m_log.Warn("Inventory asset upload contained no data");
}
// Build the response message
OSDMap reply = new OSDMap
{
{ "state", OSD.FromString("complete") },
{ "new_asset", OSD.FromUUID(assetID) },
{ "new_inventory_item", OSD.FromUUID(itemID) }
};
LLUtil.SendLLSDXMLResponse(response, reply);
}
public static Capability <string> FromFocusMode(Capability <string> info)
{
return(AsDisplayNames <string>(info, FromFocusMode));
}
private void NewFileAgentInventoryVariablePriceUploadHandler(NewFileAgentInventoryVariablePriceMessage message, Capability cap,
IHttpClientContext context, IHttpRequest request, IHttpResponse response)
{
byte[] assetData = request.GetBody();
UUID assetID = UUID.Zero;
LLInventoryItem item = null;
m_log.Debug("Received inventory asset upload from " + cap.OwnerID + " (" + assetData.Length + " bytes)");
if (assetData != null && assetData.Length > 0)
{
string contentType = LLUtil.LLAssetTypeToContentType((int)message.AssetType);
// Create the asset
if (m_assetClient.StoreAsset(contentType, false, false, assetData, cap.OwnerID, out assetID))
{
// Create the inventory item
item = new LLInventoryItem();
item.AssetID = assetID;
item.ContentType = contentType;
item.CreationDate = DateTime.UtcNow;
item.CreatorID = cap.OwnerID;
item.Description = message.Description;
item.ID = UUID.Random();
item.Name = message.Name;
item.OwnerID = cap.OwnerID;
item.ParentID = message.FolderID;
Permissions perms = (m_permissions != null) ? m_permissions.GetDefaultPermissions() : Permissions.FullPermissions;
perms.EveryoneMask = message.EveryoneMask;
perms.GroupMask = message.GroupMask;
perms.NextOwnerMask = message.NextOwnerMask;
item.Permissions = perms;
item.SalePrice = 10;
item.SaleType = SaleType.Not;
if (!m_inventoryClient.TryCreateItem(cap.OwnerID, item))
m_log.Warn("Failed to create inventory item for uploaded asset " + assetID);
}
else
{
m_log.WarnFormat("Failed to store uploaded inventory asset ({0} bytes)", assetData.Length);
}
}
else
{
m_log.Warn("Inventory asset upload contained no data");
}
// Build the response message
NewFileAgentInventoryUploadReplyMessage reply = new NewFileAgentInventoryUploadReplyMessage();
reply.NewAsset = assetID;
if (item != null)
{
reply.NewInventoryItem = item.ID;
reply.NewBaseMask = item.Permissions.BaseMask;
reply.NewEveryoneMask = item.Permissions.EveryoneMask;
reply.NewNextOwnerMask = item.Permissions.NextOwnerMask;
reply.NewOwnerMask = item.Permissions.OwnerMask;
}
LLUtil.SendLLSDXMLResponse(response, reply.Serialize());
}
internal static Capability <string> FromZoomSetting(Capability <string> info)
{
return(AsDisplayNames <string>(info, FromZoomSetting));
}
internal static Capability <string> FromStillQuality(Capability <string> info)
{
return(AsDisplayNames <string>(info, FromStillQuality));
}
private async Task OnSelectionChanged <T>(object sender, Capability <T> param, AsyncAction <T> action)
{
await OnComboBoxChanged(sender, param, async (selected) => { await action.Invoke(selected); });
}
