Availble parameters (passed either as GET or POST parameters):

id : user photo id as a string

This will be used to identify the image after resizing. This should allow you to identify this image.

size : designated size of image in format widthxheight

If you don't want to specify one of those parameters, just insert 0 instead of a valid value like 600x0

quality : resized image quality, in percents

The quality of resized image. By default the quality is assumed 85%. Better (bigger) quality means bigger output file.

bgcolor : the background color

The background color for background in avatar and thumbnail mode. The value can be color description in rgb like #FF0000 for pure red color or transparent string if you want to have transparent background. The transparent background works only for gif images. The default value is white #FFFFFF, for gif images and avatar mode the default is transparent.

renders black background for jpg images.

action : one of resize|thumbnail|avatar

resize

scales image in nice way. your image's size is not going to be grater than designated size (can be smaller than one of dimensions), preserving image size ratio.

Examples:

• action=scale&size=500x500 - the width and the height will never be greater than 500 pixels. If the image is vertical, the width will be 500 but the height will be fitted to blabla the blabla
• action=scale&size=500x0 - the image height will be fitted to .... and width will always be 500px

thumbnail

scales the image, but without keeping the ratio. The dest image will be always have width and height exactly as you requestd.

Examples:

• action=thumbnail&size=50x50 - the image will be exactly 50x50, no mater of the source size

avatar

does exactly the same as thumbnail except that gif animations are kept.

callback : user callback url

The resized image will be uploaded there automatically just after the resizing. The resized image is going to be PUSHed on this url, with parameters:

id

client's id that you used while uploading the image

size

size you requested in format WxH

action

action you requested

file : uploaded file data

The uploaded file. You can omit this parameter and include the file contents in the body of POST request if you can't use multipart/form-data encoding. In this case all other parameters should be passed as GET parameters.

file_name : uploadef file name

If you're sending file data in the body of POST request (when you can't use multipart/form-data) you can explicite set filename. This can be useful if you want to resize gif images.

Return codes:

200

image resize schedules succesfully

400

one of the parameters has wrong value

Parameters:

callback

uri to be downloaded at a specific time

time

Time that says when to download specified site. This parameter can be in formats:

+10

The callback site is going to be downloaded 10 minutes from now.

+1:10

The callback site is going to be downloaded one hour and 10 minutes from now, this one is equalivent to +70.

21:12

The callback will occur at specified hour UTC.

Return codes:

200

request scheduled succesfully

400

the time is in wrong format

This is the file with all our javascript scripts. It's less than 500 lines long, so you can try to read the source.

Constants:

comet_restart_timeout

How long to wait befor reconnecting when the comet connection is broken (in milliseconds, 5 seconds by default.)

comet_keepalive_timeout

How long can a connection last without any messages passing. The connection will be recreated after this time unless some event occurs. (in milliseconds, 76 seconds by default, this should be okay for 60-seconds keepalive timer)

The important functions:

comet_connection(url, user_callback)

This is the main function that creates comet connection. It also reconnects if the keepalive is not received before comet_keepalive_timeout.

This function is probably useless for you, because it assumes that the comet server is in the same domain as your site.

Usage example:

<script>
    function callback(data){
        alert('got event: ' + data);
    }
    /* comet is on the same server as this site */
    comet_connection('/path/to/comet/listen', callback);
</script>

Parameters:

url

This can be a string that is valid url to long comet connection. It can also be a function which returns url. The function will be executed every time the url is needed, that means before the first connection and before every reconnection. The url must be local.

user_callback

Your callback function, it's going to be executed every time the data will appear on connection.

comet_schedule_crossdomain(iframe_uri, comet_uri, user_callback)

The function is a wrapper for comet_connection, which does exactly the same as previous function except that it works cross-domain. It loads the iframe_uri into an iframe, sets document.domain and passes parameters.

You should set domain comet.yourdomain.com to point to our servers.

Before running this function make sure that document.domain on your site is set to good value.

Usage example:

<script>
    /* yoursubdom.yourdomain.com -> yourdomain.com */
    document.domain = extract_xss_domain(document.domain);

    function callback(data){
        alert('got event: ' + data);
    }
    /* comet.yourdomain.com points to our server */
    comet_schedule_crossdomain('http://comet.yourdomain.com/_/iframe.html', '/comet/' + channel_id + '/listen', callback);
</script>

For our service the data received by your callback can be:

keepalive_message

If no event occurs for a period of time. server sends keepalive message with the message you specified when creating the channel. By default it's ping string.

connect_message username

Just after connecting, the server can send you last 10 messages. After this events the server sends connect message you specified when creating the channel. By default its connect string. After the connect string the current set username is appended. If you haven't specified username while connecting to listen service, it will be set to random value.

'destroyed' string

When the channel is destroied this string is received by all the listeners. You must create new channel and receive the new channel_id in all browsers.

event_id author message

Normal event is delivered in this format.

Details:

event_id

Numeric value that identifies current message.

author admin|guest

If the channel is public everyone can send messages. The messages that used valid event_key when sending event are marked as admin, all others as guest. If the channel is not public, only admin messages will occurr.

message

The sent message. It's not escaped, so please be sure to quote it before viewing.

More specific example of user callback function:

<script>
var max_id = 0;
function comet_callback(data){
    var a      = data.split(' ');
    var id     = a[0];
    var author = a[1];

    /* system messages */
    if(id == 'connected'){
        username = author;
        return;
    }
    if(id == 'ping'){
        return;
    }
    if(id == 'destroyed'){
        // this channel_id is no longer valid
        return;
    }
    id = Number(id);

    /* ignore duplicate events */
    if(id <= max_id)
        return;
    max_id = id;

    /* user event */
    var message  = a.slice(2).join(' ');

    alert('event_id:' + id + ' author:' + author + ' message:' + message);
}
</script>

ajax_crossdomain(iframe_uri, method, ajax_uri, user_callback, post_data)

Sometimes you could need to send normal ajax requests to our comet service. This can't be done straightforward - domains don't match. To do this you can use this wraper.

For example common case is to send events directly from browser to our server, rather than to your site. This code can help you:

Usage example:

<script>
    /* yoursubdom.yourdomain.com -> yourdomain.com */
    document.domain = extract_xss_domain(document.domain);

    function cb(o){
        /* the parameter is the connection object from YUI
           see: http://developer.yahoo.com/yui/examples/connection/post.html
        */
        if(o.status != 200)
            alert('sending event failed');
    }
    ajax_crossdomain('http://comet.yourdomain.com/_/crossajax.html', 'POST', '/comet/' + channel_id + '/event', cb,
            'data=' + escape('this is the message!') );
</script>

Parameters:

event_callback_uri

send received event data not only to the clients, but also to this url (which is short connection) Will be send using POST method and the data will be in parameter event.

keepalive_time

How often to send keepalive data. 60 seconds by default, 120 seconds max.

keepalive_message

Message to be send on keepalive event. By default this is 'ping' string.

connect_message

Data to be sent to client just after connecting. By default this is 'connected', to look like keepalive message.

public

Is the chalnnel public? anyone can send events? should be False|True.

Return codes:

200

new channel created successfully

Returns identifier to the new channel and security key for sending events and another one for destoring the chanenel

informaton about the channel. users listening, how many events/connection send since createion, createion time, latency problems etc.

Return codes:

200

information page got sucessfuly

404

channel doesn't exist

will return 200 status code if the channel exists or 404 else.

long-polling connection from the channel (used in javascript on the browsers side)

Parameters:

last_eventid

eventid of the last message received by the listener. If this parameter is not specified last 10 events are repeated.

username

username to identify this connection. Can be empty.

Comet specific parameters:

transport

transport type, could be one of basic|iframe|htmlfile|server_sent_events|sse|xhr|xhr_stream|xhr_multipart. See Orbited project for details.

callback

callback function. Used for transports htmlfile|iframe

domain

currently ignored.

Return codes:

200

everything okay, this connection is long one.

404

channel doesn't exist

You rather won't use this uri directly. Please see our javascript interface function comet_schedule_crossdomain.

sends an event to every listener

Parameters:

data

data to be send (you're responsible for escaping the data if needed). This data shouldn't contain more than 256 bytes for one event.

event_key

secret key needed to send data (received when creating channel) if channel is not public. if it's - no event_key is needed

Return codes:

200

event send

204

data is empty

403

event_key is not valid, you're not allowed to send events

404

channel doesn't exist

If you need to send events from browser to channel, please consider our javascript method ajax_crossdomain. Remember about setting the channel to be public or pass valid event_key to the browsers.

Parameters:

destroy_key

must be a valid security key for destroying the channel

destroies the channel.

the channel is going to be destroyed automatically about 24 hours after last received event.

Return codes:

200

channel destroyed

403

destroy_key is not valid, you're not allowed to destroy this channel

404

channel doesn't exist