OpenMetaverse.AssetManager.RequestUploadBakedTexture C# (CSharp) Method

        public void RequestUploadBakedTexture(byte[] textureData, BakedTextureUploadedCallback callback)
        {
            Uri url = null;

            Caps caps = Client.Network.CurrentSim.Caps;
            if (caps != null)
                url = caps.CapabilityURI("UploadBakedTexture");

            if (url != null)
            {
                // Fetch the uploader capability
                CapsClient request = new CapsClient(url);
                request.OnComplete +=
                    delegate(CapsClient client, OSD result, Exception error)
                    {
                        if (error == null && result is OSDMap)
                        {
                            UploadBakedTextureMessage message = new UploadBakedTextureMessage();
                            message.Deserialize((OSDMap)result);

                            if (message.Request.State == "upload")
                            {
                                Uri uploadUrl = ((UploaderRequestUpload)message.Request).Url;

                                if (uploadUrl != null)
                                {
                                    // POST the asset data
                                    CapsClient upload = new CapsClient(uploadUrl);
                                    upload.OnComplete +=
                                        delegate(CapsClient client2, OSD result2, Exception error2)
                                        {
                                            if (error2 == null && result2 is OSDMap)
                                            {
                                                UploadBakedTextureMessage message2 = new UploadBakedTextureMessage();
                                                message2.Deserialize((OSDMap)result2);

                                                if (message2.Request.State == "complete")
                                                {
                                                    callback(((UploaderRequestComplete)message2.Request).AssetID);
                                                    return;
                                                }
                                            }

                                            Logger.Log("Bake upload failed during asset upload", Helpers.LogLevel.Warning, Client);
                                            callback(UUID.Zero);
                                        };
                                    upload.BeginGetResponse(textureData, "application/octet-stream", Client.Settings.CAPS_TIMEOUT);
                                    return;
                                }
                            }
                        }

                        Logger.Log("Bake upload failed during uploader retrieval", Helpers.LogLevel.Warning, Client);
                        callback(UUID.Zero);
                    };
                request.BeginGetResponse(new OSDMap(), OSDFormat.Xml, Client.Settings.CAPS_TIMEOUT);
            }
            else
            {
                Logger.Log("UploadBakedTexture not available, falling back to UDP method", Helpers.LogLevel.Info, Client);

                ThreadPool.QueueUserWorkItem(
                    delegate(object o)
                    {
                        UUID transactionID = UUID.Random();
                        BakedTextureUploadedCallback uploadCallback = (BakedTextureUploadedCallback)o;
                        AutoResetEvent uploadEvent = new AutoResetEvent(false);
                        EventHandler<AssetUploadEventArgs> udpCallback =
                            delegate(object sender, AssetUploadEventArgs e)
                            {
                                if (e.Upload.ID == transactionID)
                                {
                                    uploadEvent.Set();
                                    uploadCallback(e.Upload.Success ? e.Upload.AssetID : UUID.Zero);
                                }
                            };

                        AssetUploaded += udpCallback;

                        UUID assetID;
                        bool success;

                        try
                        {
                            RequestUpload(out assetID, AssetType.Texture, textureData, true, transactionID);
                            success = uploadEvent.WaitOne(Client.Settings.TRANSFER_TIMEOUT, false);
                        }
                        catch (Exception)
                        {
                            success = false;
                        }

                        AssetUploaded -= udpCallback;

                        if (!success)
                            uploadCallback(UUID.Zero);
                    }, callback
                );
            }
        }