URLSession.c File Reference

#include <assert.h>
#include <curl/curl.h>
#include "URLSession.h"

Go to the source code of this file.

Macros
#define	_Class   _URLSession

Functions
Class *	_URLSession (void)
static URLSessionDataTask *	dataTaskWithRequest (URLSession *self, URLRequest *request, URLSessionTaskCompletion completion)
static URLSessionDataTask *	dataTaskWithURL (URLSession *self, URL *url, URLSessionTaskCompletion completion)
static void	dealloc (Object *self)
static void	destroy (Class *clazz)
static URLSessionDownloadTask *	downloadTaskWithRequest (URLSession *self, URLRequest *request, URLSessionTaskCompletion completion)
static URLSessionDownloadTask *	downloadTaskWithURL (URLSession *self, URL *url, URLSessionTaskCompletion completion)
static URLSession *	init (URLSession *self)
static void	initialize (Class *clazz)
static URLSession *	initWithConfiguration (URLSession *self, URLSessionConfiguration *configuration)
static void	invalidateAndCancel (URLSession *self)
static ident	run (Thread *thread)
	ThreadFunction for a URLSession.
static URLSession *	sharedInstance (void)
static Array *	tasks (const URLSession *self)
static ident	taskWithRequest (URLSession *self, ident task, URLRequest *request, URLSessionTaskCompletion completion)
	URLSessionTask factory function.
static URLSessionUploadTask *	uploadTaskWithRequest (URLSession *self, URLRequest *request, URLSessionTaskCompletion completion)

Variables
static URLSession *	_sharedInstance

Macro Definition Documentation

_Class

#define _Class   _URLSession

Definition at line 30 of file URLSession.c.

Function Documentation

_URLSession()

Class * _URLSession

(

void

)

Definition at line 414 of file URLSession.c.

                         {
  static Class *clazz;
  static Once once;
 
  do_once(&once, {
    clazz = _initialize(&(const ClassDef) {
      .name = "URLSession",
      .superclass = _Object(),
      .instanceSize = sizeof(URLSession),
      .interfaceOffset = offsetof(URLSession, interface),
      .interfaceSize = sizeof(URLSessionInterface),
      .initialize = initialize,
      .destroy = destroy,
    });
  });
 
  return clazz;
}

dataTaskWithRequest()

static URLSessionDataTask * dataTaskWithRequest ( URLSession *  self, URLRequest *  request, URLSessionTaskCompletion  completion  )

static

Definition at line 76 of file URLSession.c.

                                                                                                                           {
 
  URLSessionDataTask *task = (URLSessionDataTask *) $((URLSessionTask *) alloc(URLSessionDataTask),
      initWithRequestInSession, request, self, completion);
  if (task) {
 
    URLCache *cache = self->configuration->urlCache;
    if (cache) {
      task->cachedResponse = $(cache, cachedResponseForRequest, request);
      if (task->cachedResponse) {
        return task;
      }
    }
 
    synchronized(self->locals.condition, {
      $(self->locals.tasks, addObject, task);
      $(self->locals.condition, signal);
    });
  }
 
  return task;
}

dataTaskWithURL()

static URLSessionDataTask * dataTaskWithURL ( URLSession *  self, URL *  url, URLSessionTaskCompletion  completion  )

static

Definition at line 103 of file URLSession.c.

                                                                                                            {
 
  URLRequest *request = $(alloc(URLRequest), initWithURL, url);
  request->httpMethod = HTTP_GET;
 
  URLSessionDataTask *task = $(self, dataTaskWithRequest, request, completion);
 
  release(request);
 
  return task;
}

dealloc()

static void dealloc ( Object *  self )

static

See also

Object::dealloc(Object *)

Definition at line 37 of file URLSession.c.

                                  {
 
  URLSession *this = (URLSession *) self;
 
  $(this, invalidateAndCancel);
 
  $(this->locals.thread, join, NULL);
 
  release(this->locals.condition);
  release(this->locals.thread);
  release(this->locals.tasks);
  release(this->configuration);
 
  super(Object, self, dealloc);
}

destroy()

static void destroy ( Class *  clazz )

static

See also

Class::destroy(Class *)

Definition at line 381 of file URLSession.c.

                                  {
 
  _sharedInstance = release(_sharedInstance);
 
  curl_global_cleanup();
}

downloadTaskWithRequest()

static URLSessionDownloadTask * downloadTaskWithRequest ( URLSession *  self, URLRequest *  request, URLSessionTaskCompletion  completion  )

static

Definition at line 119 of file URLSession.c.

                                                                                                                                   {
 
  return taskWithRequest(self, alloc(URLSessionDownloadTask), request, completion);
}

downloadTaskWithURL()

static URLSessionDownloadTask * downloadTaskWithURL ( URLSession *  self, URL *  url, URLSessionTaskCompletion  completion  )

static

Definition at line 128 of file URLSession.c.

                                                                                                                    {
 
  URLRequest *request = $(alloc(URLRequest), initWithURL, url);
 
  URLSessionDownloadTask *task = $(self, downloadTaskWithRequest, request, completion);
 
  release(request);
 
  return task;
}

init()

static URLSession * init ( URLSession *  self )

static

Definition at line 143 of file URLSession.c.

                                          {
 
  URLSessionConfiguration *configuration = $(alloc(URLSessionConfiguration), init);
 
  self = $(self, initWithConfiguration, configuration);
 
  release(configuration);
 
  return self;
}

initialize()

static void initialize ( Class *  clazz )

static

See also

Class::initialize(Class *)

Definition at line 391 of file URLSession.c.

                                     {
 
  ((ObjectInterface *) clazz->interface)->dealloc = dealloc;
 
  ((URLSessionInterface *) clazz->interface)->dataTaskWithRequest = dataTaskWithRequest;
  ((URLSessionInterface *) clazz->interface)->dataTaskWithURL = dataTaskWithURL;
  ((URLSessionInterface *) clazz->interface)->downloadTaskWithRequest = downloadTaskWithRequest;
  ((URLSessionInterface *) clazz->interface)->downloadTaskWithURL = downloadTaskWithURL;
  ((URLSessionInterface *) clazz->interface)->init = init;
  ((URLSessionInterface *) clazz->interface)->initWithConfiguration = initWithConfiguration;
  ((URLSessionInterface *) clazz->interface)->invalidateAndCancel = invalidateAndCancel;
  ((URLSessionInterface *) clazz->interface)->sharedInstance = sharedInstance;
  ((URLSessionInterface *) clazz->interface)->tasks = tasks;
  ((URLSessionInterface *) clazz->interface)->uploadTaskWithRequest = uploadTaskWithRequest;
 
  const CURLcode code = curl_global_init(CURL_GLOBAL_ALL);
  assert(code == CURLE_OK);
}

initWithConfiguration()

static URLSession * initWithConfiguration ( URLSession *  self, URLSessionConfiguration *  configuration  )

static

Definition at line 293 of file URLSession.c.

                                                                                                   {
 
  assert(configuration);
 
  self = (URLSession *) super(Object, self, init);
  if (self) {
    self->configuration = retain(configuration);
 
    self->locals.condition = $(alloc(Condition), init);
    self->locals.tasks = $(alloc(Array), init);
    self->locals.thread = $(alloc(Thread), initWithFunction, run, self);
 
    $(self->locals.thread, start);
  }
 
  return self;
}

invalidateAndCancel()

static void invalidateAndCancel ( URLSession *  self )

static

Definition at line 315 of file URLSession.c.

                                                  {
 
  if (self->locals.thread->isCancelled) {
    return;
  }
 
  Array *tasks = $(self, tasks);
 
  for (size_t i = 0; i < tasks->count; i++) {
 
    URLSessionTask *task = $(tasks, objectAtIndex, i);
    $(task, cancel);
  }
 
  release(tasks);
 
  $(self->locals.thread, cancel);
  synchronized(self->locals.condition, $(self->locals.condition, signal));
}

run()

static ident run ( Thread *  thread )

static

ThreadFunction for a URLSession.

Definition at line 157 of file URLSession.c.

                                 {
 
  URLSession *self = thread->data;
 
  self->locals.handle = curl_multi_init();
  assert(self->locals.handle);
 
  while (true) {
    int ret;
 
    bool idle;
    synchronized(self->locals.condition, {
      while (!thread->isCancelled && self->locals.tasks->count == 0) {
        $(self->locals.condition, wait);
      }
      idle = thread->isCancelled && self->locals.tasks->count == 0;
    });
 
    if (idle) {
      break;
    }
 
    Array *tasks = $(self, tasks);
 
    for (size_t i = 0; i < tasks->count; i++) {
 
      URLSessionTask *task = $(tasks, objectAtIndex, i);
      if (task->state == URLSESSIONTASK_SUSPENDING) {
 
        if (task->locals.handle) {
          const CURLcode err = curl_easy_pause(task->locals.handle, CURLPAUSE_ALL);
          assert(err == CURLE_OK);
        }
 
        task->state = URLSESSIONTASK_SUSPENDED;
 
      } else if (task->state == URLSESSIONTASK_RESUMING) {
 
        if (task->locals.handle == NULL) {
 
          $(task, setup);
          assert(task->locals.handle);
 
          const CURLMcode merr = curl_multi_add_handle(self->locals.handle, task->locals.handle);
          assert(merr == CURLM_OK);
        } else {
          const CURLcode err = curl_easy_pause(task->locals.handle, CURLPAUSE_CONT);
          assert(err == CURLE_OK);
        }
 
        task->state = URLSESSIONTASK_RESUMED;
 
      } else if (task->state == URLSESSIONTASK_CANCELING) {
 
        if (task->locals.handle) {
          const CURLMcode merr = curl_multi_remove_handle(self->locals.handle, task->locals.handle);
          assert(merr == CURLM_OK);
        }
 
        task->state = URLSESSIONTASK_CANCELED;
 
        if (task->completion) {
          task->completion(task, false);
        }
 
        $(task, teardown);
 
        synchronized(self->locals.condition, {
          $(self->locals.tasks, removeObject, task);
        });
      } else if (task->state == URLSESSIONTASK_COMPLETED) {
 
        synchronized(self->locals.condition, {
          $(self->locals.tasks, removeObject, task);
        });
      }
    }
 
    CURLMcode merr = curl_multi_wait(self->locals.handle, NULL, 0, 0, NULL);
    assert(merr == CURLM_OK);
 
    merr = curl_multi_perform(self->locals.handle, &ret);
    assert(merr == CURLM_OK);
 
    CURLMsg *message;
    while ((message = curl_multi_info_read(self->locals.handle, &ret))) {
 
      URLSessionTask *task = NULL;
      for (size_t i = 0; i < tasks->count; i++) {
 
        URLSessionTask *t = $(tasks, objectAtIndex, i);
        if (t->locals.handle == message->easy_handle) {
          task = t;
          break;
        }
      }
 
      assert(task);
 
      if (message->msg == CURLMSG_DONE) {
 
        merr = curl_multi_remove_handle(self->locals.handle, task->locals.handle);
        assert(merr == CURLM_OK);
 
        task->state = URLSESSIONTASK_COMPLETED;
 
        curl_easy_getinfo(task->locals.handle, CURLINFO_RESPONSE_CODE, (long *) &task->response->httpStatusCode);
 
        if (message->data.result == CURLE_OK && $((Object *) task, isKindOfClass, _URLSessionDataTask())) {
          $((URLSessionDataTask *) task, cacheResponse);
        }
 
        if (task->completion) {
          task->completion(task, message->data.result == CURLE_OK);
        }
 
        $(task, teardown);
 
        synchronized(self->locals.condition, {
          $(self->locals.tasks, removeObject, task);
        });
      }
    }
 
    release(tasks);
  }
 
  curl_multi_cleanup(self->locals.handle);
 
  return NULL;
}

sharedInstance()

static URLSession * sharedInstance ( void  )

static

Definition at line 341 of file URLSession.c.

                                        {
 
  static Once once;
 
  do_once(&once, {
    _sharedInstance = $(alloc(URLSession), init);
  });
 
  return _sharedInstance;
}

tasks()

static Array * tasks ( const URLSession *  self )

static

Definition at line 356 of file URLSession.c.

                                            {
 
  Array *array;
 
  synchronized(self->locals.condition, {
    array = $$(Array, arrayWithArray, (Array *) self->locals.tasks);
  });
 
  return array;
}

taskWithRequest()

static ident taskWithRequest ( URLSession *  self, ident  task, URLRequest *  request, URLSessionTaskCompletion  completion  )

static

URLSessionTask factory function.

Definition at line 58 of file URLSession.c.

                                                                                                                     {
 
  task = $((URLSessionTask *) task, initWithRequestInSession, request, self, completion);
  if (task) {
 
    synchronized(self->locals.condition, {
      $(self->locals.tasks, addObject, task);
      $(self->locals.condition, signal);
    });
  }
 
  return task;
}

uploadTaskWithRequest()

static URLSessionUploadTask * uploadTaskWithRequest ( URLSession *  self, URLRequest *  request, URLSessionTaskCompletion  completion  )

static

Definition at line 371 of file URLSession.c.

                                                                                                                               {
 
  return taskWithRequest(self, alloc(URLSessionUploadTask), request, completion);
}

Variable Documentation

_sharedInstance

URLSession* _sharedInstance

static

Definition at line 335 of file URLSession.c.