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. More...
static URLSession *	sharedInstance (void)
static Array *	tasks (const URLSession *self)
static ident	taskWithRequest (URLSession *self, ident task, URLRequest *request, URLSessionTaskCompletion completion)
	URLSessionTask factory function. More...
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 389 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.

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

dataTaskWithURL()

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

static

Definition at line 85 of file URLSession.c.

                                                                                                            {
 
    URLRequest *request = $(alloc(URLRequest), initWithURL, url);
 
    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);
 
    super(Object, self, dealloc);
}

destroy()

static void destroy ( Class *  clazz )

static

See also

Class::destroy(Class *)

Definition at line 378 of file URLSession.c.

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

downloadTaskWithRequest()

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

static

Definition at line 100 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 109 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 124 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 356 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 267 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.lock = $(alloc(Lock), init);
        self->locals.tasks = $(alloc(MutableArray), 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 290 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);
    $(self->locals.condition, signal);
}

run()

static ident run ( Thread *  thread )

static

ThreadFunction for a URLSession.

Definition at line 138 of file URLSession.c.

                                 {
 
    URLSession *self = thread->data;
 
    self->locals.handle = curl_multi_init();
    assert(self->locals.handle);
 
    while (true) {
        int ret;
 
        Array *tasks = $(self, tasks);
        if (tasks->count == 0) {
 
            if (thread->isCancelled) {
                break;
            }
 
            $(self->locals.condition, wait);
            continue;
        }
 
        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.lock, {
                    $(self->locals.tasks, removeObject, task);
                });
            } else if (task->state == URLSESSIONTASK_COMPLETED) {
 
                synchronized(self->locals.lock, {
                    $(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 (task->completion) {
                    task->completion(task, message->data.result == CURLE_OK);
                }
 
                $(task, teardown);
 
                synchronized(self->locals.lock, {
                    $(self->locals.tasks, removeObject, task);
                });
            }
        }
 
        release(tasks);
    }
 
    curl_multi_cleanup(self->locals.handle);
 
    return NULL;
}

sharedInstance()

static URLSession * sharedInstance ( void  )

static

Definition at line 316 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 331 of file URLSession.c.

                                            {
 
    Array *array;
 
    synchronized(self->locals.lock, {
        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 57 of file URLSession.c.

                                                                                                                     {
 
    task = $((URLSessionTask *) task, initWithRequestInSession, request, self, completion);
    if (task) {
 
        synchronized(self->locals.lock, {
            $(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 346 of file URLSession.c.

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

Variable Documentation

_sharedInstance

URLSession* _sharedInstance

static

Definition at line 310 of file URLSession.c.