public void GetImageAsync(FacebookImageDimensions requestedSize, GetImageSourceAsyncCallback callback)
{
Verify.IsNotNull(callback, "callback");
Assert.IsNotNull(SourceService);
Assert.IsNotNull(SourceService.WebGetter);
SmallUri ss = _GetSmallUriFromRequestedSize(requestedSize);
if (ss == default(SmallUri))
{
callback(this, new GetImageSourceCompletedEventArgs(new InvalidOperationException("The requested image doesn't exist"), false, this));
}
BitmapSource img;
if (_TryGetFromWeakCache(requestedSize, out img))
{
callback(this, new GetImageSourceCompletedEventArgs(img, this));
}
var userState = new _ImageCallbackState {
Callback = callback, RequestedSize = requestedSize
};
SourceService.WebGetter.GetImageSourceAsync(this, userState, ss, _AddWeakCacheCallback);
}
/// <summary>
/// Starts download of requested image
/// </summary>
/// <param name="requestedSize">Size of the image</param>
/// <param name="callback">Callback that will be called when download completes</param>
public void GetImageAsync(FacebookImageDimensions requestedSize, GetImageSourceAsyncCallback callback)
{
#if !SILVERLIGHT
dispatcher = Dispatcher.CurrentDispatcher;
#else
dispatcher = System.Windows.Deployment.Current.Dispatcher;
#endif
Uri = _normal;
switch (requestedSize)
{
case FacebookImageDimensions.Big: Uri = _big; break;
case FacebookImageDimensions.Small: Uri = _small; break;
case FacebookImageDimensions.Square: Uri = _square; break;
}
if (Uri == null)
{
callback(this, new GetImageSourceCompletedEventArgs(new InvalidOperationException(), false, this));
return;
}
WebClientHelper wc = new WebClientHelper(callback);
wc.RequestCompleted += new EventHandler <RequestCompletedEventArgs>(wc_RequestCompleted);
wc.SendRequest(Uri, null, null);
}
void wc_RequestCompleted(object sender, RequestCompletedEventArgs e)
{
WebClientHelper wc = sender as WebClientHelper;
ContentType = wc.ContentType;
dispatcher.BeginInvoke(new Action(() =>
{
GetImageSourceCompletedEventArgs eventArgs;
if (e.Error != null)
{
eventArgs = new GetImageSourceCompletedEventArgs(e.Error, false, this);
}
else
{
try
{
eventArgs = CreateBitmapFromStream(e.Response);
}
finally
{
e.Response.Close();
}
}
GetImageSourceAsyncCallback callback = (GetImageSourceAsyncCallback)e.UserState;
callback(this, eventArgs);
}));
}
private void _ProcessNextLocalRequest(object unused)
{
while (_asyncPhotoPool != null)
{
// Retrieve the next data request for processing.
GetImageSourceAsyncCallback callback = null;
object userState = null;
object sender = null;
SmallUri ssUri = default(SmallUri);
lock (_localLock)
{
while (_activePhotoRequests.Count > 0)
{
_DataRequest nextDataRequest = _activePhotoRequests.Pop();
Assert.IsTrue(nextDataRequest.Callback is GetImageSourceAsyncCallback);
if (!nextDataRequest.Canceled)
{
sender = nextDataRequest.Sender;
callback = (GetImageSourceAsyncCallback)nextDataRequest.Callback;
userState = nextDataRequest.UserState;
ssUri = nextDataRequest.SmallUri;
break;
}
}
if (ssUri == default(SmallUri))
{
Assert.AreEqual(0, _activePhotoRequests.Count);
return;
}
}
Assert.IsNotNull(callback);
GetImageSourceCompletedEventArgs callbackArgs = null;
string localCachePath = null;
try
{
localCachePath = _GetCacheLocation(ssUri);
if (localCachePath == null)
{
callbackArgs = new GetImageSourceCompletedEventArgs(new FileNotFoundException(), false, userState);
}
else
{
using (Stream imageStream = File.Open(localCachePath, FileMode.Open, FileAccess.Read, FileShare.Read))
{
callbackArgs = new GetImageSourceCompletedEventArgs(_GetBitmapSourceFromStream(imageStream), userState);
}
}
}
catch (Exception e)
{
if (!string.IsNullOrEmpty(localCachePath))
{
// If the cache is bad try removing the file so we can fetch it correctly next time.
try
{
File.Delete(localCachePath);
}
catch { }
}
callbackArgs = new GetImageSourceCompletedEventArgs(e, false, userState);
}
_callbackDispatcher.BeginInvoke(callback, sender, callbackArgs);
}
}
public void GetImageSourceAsync(object sender, object userState, SmallUri ssUri, GetImageSourceAsyncCallback callback)
{
//Verify.UriIsAbsolute(uri, "uri");
Verify.IsNotNull(sender, "sender");
// UserState may be null.
// Verify.IsNotNull(userState, "userState");
Verify.IsNotNull(callback, "callback");
if (_disposed)
{
callback(this, new GetImageSourceCompletedEventArgs(new ObjectDisposedException("this"), false, userState));
return;
}
if (default(SmallUri) == ssUri)
{
callback(this, new GetImageSourceCompletedEventArgs(new ArgumentException("The requested image doesn't exist.", "ssUri"), false, userState));
return;
}
// Make asynchronous request to get ImageSource object from the data feed.
var imageRequest = new _DataRequest
{
Sender = sender,
UserState = userState,
SmallUri = ssUri,
Callback = callback,
};
bool needToCache = _GetCacheLocation(ssUri) == null;
if (needToCache)
{
bool needToQueue = false;
lock (_webLock)
{
needToQueue = !_asyncWebRequestPool.HasPendingRequests;
_activeWebRequests.Push(imageRequest);
}
if (needToQueue)
{
_asyncWebRequestPool.QueueRequest(_ProcessNextWebRequest, null);
_asyncWebRequestPool.QueueRequest(_ProcessNextWebRequest, null);
}
}
else
{
bool needToQueue = false;
lock (_localLock)
{
needToQueue = !_asyncPhotoPool.HasPendingRequests;
_activePhotoRequests.Push(imageRequest);
}
if (needToQueue)
{
_asyncPhotoPool.QueueRequest(_ProcessNextLocalRequest, null);
}
}
}
/// <summary>
/// Starts download of requested image
/// </summary>
/// <param name="requestedSize">Size of the image</param>
/// <param name="callback">Callback that will be called when download completes</param>
public void GetImageAsync(FacebookImageDimensions requestedSize, GetImageSourceAsyncCallback callback)
{
#if !SILVERLIGHT
dispatcher = Dispatcher.CurrentDispatcher;
#else
dispatcher = System.Windows.Deployment.Current.Dispatcher;
#endif
Uri = _normal;
switch (requestedSize)
{
case FacebookImageDimensions.Big: Uri = _big; break;
case FacebookImageDimensions.Small: Uri = _small; break;
case FacebookImageDimensions.Square: Uri = _square; break;
}
if (Uri == null)
{
callback(this, new GetImageSourceCompletedEventArgs(new InvalidOperationException(), false, this));
return;
}
WebClientHelper wc = new WebClientHelper(callback);
wc.RequestCompleted += new EventHandler<RequestCompletedEventArgs>(wc_RequestCompleted);
wc.SendRequest(Uri, null, null);
}
