diff --git a/blackberry/tibb/NativeHttpClientObject.cpp b/blackberry/tibb/NativeHttpClientObject.cpp
new file mode 100644
index 0000000..a17d649
--- /dev/null
+++ b/blackberry/tibb/NativeHttpClientObject.cpp
@@ -0,0 +1,288 @@
+/**
+ * Appcelerator Titanium Mobile
+ * Copyright (c) 2009-2012 by Appcelerator, Inc. All Rights Reserved.
+ * Licensed under the terms of the Apache Public License
+ * Please see the LICENSE included with this distribution for details.
+ */
+
+#include "NativeHttpClientObject.h"
+
+#include "NativeControlObject.h"
+#include "TiObject.h"
+#include <QUrl.h>
+#include <QtNetwork/qnetworkrequest.h>
+#include "TiV8Event.h"
+#include "TiHttpClientObject.h"
+
+#pragma GCC diagnostic ignored "-Wunused-parameter"
+#include <v8.h>
+#pragma GCC diagnostic warning "-Wunused-parameter"
+
+using namespace v8;
+
+#define PROP_SETGET_FUNCTION(NAME)      prop_##NAME
+
+#define PROP_SETGET(NAME)               static int prop_##NAME(NativeHttpClientObject* httpClient, TiObject* obj, void * userContext) \
+    {\
+        return httpClient->NAME(obj, userContext);\
+    }
+
+#define GET_ARRAY_SIZE(ARRAY)           (int)(sizeof(ARRAY)/sizeof(*(ARRAY)))
+
+typedef int (*NATIVE_PROPSETGET_CALLBACK)(NativeHttpClientObject*, TiObject*, void*);
+
+struct NATIVE_PROPSETGET_SETTING
+{
+	NATIVE_HTTP_CLIENT_PROP propNumber;
+    NATIVE_PROPSETGET_CALLBACK setter;
+    NATIVE_PROPSETGET_CALLBACK getter;
+};
+
+class SetGetHTTPClientProperties
+{
+public:
+	SetGetHTTPClientProperties(const NATIVE_PROPSETGET_SETTING* map, int mapEntries)
+    {
+        setters_ = new NATIVE_PROPSETGET_CALLBACK[N_HTTP_CLIENT_PROP_LAST];
+        memset(setters_, 0, sizeof(NATIVE_PROPSETGET_CALLBACK) * N_HTTP_CLIENT_PROP_LAST);
+        getters_ = new NATIVE_PROPSETGET_CALLBACK[N_HTTP_CLIENT_PROP_LAST];
+        memset(getters_, 0, sizeof(NATIVE_PROPSETGET_CALLBACK) * N_HTTP_CLIENT_PROP_LAST);
+        for (int i = 0; i < mapEntries; i++)
+        {
+            setters_[map[i].propNumber] = map[i].setter;
+            getters_[map[i].propNumber] = map[i].getter;
+        }
+    }
+    ~SetGetHTTPClientProperties()
+    {
+        if (setters_ != NULL)
+        {
+            delete[] setters_;
+            setters_ = NULL;
+        }
+        if (getters_ != NULL)
+        {
+            delete[] getters_;
+            getters_ = NULL;
+        }
+    }
+    NATIVE_PROPSETGET_CALLBACK GetSetterCallback(size_t prop)
+    {
+        if (prop >= (std::size_t)N_HTTP_CLIENT_PROP_LAST)
+        {
+            return NULL;
+        }
+        return setters_[prop];
+    }
+    NATIVE_PROPSETGET_CALLBACK GetGetterCallback(size_t prop)
+    {
+        if (prop >= (std::size_t)N_HTTP_CLIENT_PROP_LAST)
+        {
+            return NULL;
+        }
+        return getters_[prop];
+    }
+private:
+    SetGetHTTPClientProperties(const SetGetHTTPClientProperties&);
+    SetGetHTTPClientProperties& operator=(const SetGetHTTPClientProperties&);
+    NATIVE_PROPSETGET_CALLBACK* setters_;
+    NATIVE_PROPSETGET_CALLBACK* getters_;
+};
+
+PROP_SETGET(setValidateSecureSertificate)
+int NativeHttpClientObject::setValidateSecureSertificate(TiObject* obj, void* /*userContext*/)
+{
+    int error = NativeControlObject::getBoolean(obj, &validateSecureSert_);
+    if (!N_SUCCEEDED(error))
+    {
+        return error;
+    }
+    return NATIVE_ERROR_OK;
+}
+
+PROP_SETGET(getValidateSecureSertificate)
+int NativeHttpClientObject::getValidateSecureSertificate(TiObject* obj, void* /*userContext*/)
+{
+    obj->setValue(Boolean::New(validateSecureSert_));
+    return NATIVE_ERROR_OK;
+}
+
+PROP_SETGET(setTimeout)
+int NativeHttpClientObject::setTimeout(TiObject* obj, void* /*userContext*/)
+{
+    int error = NativeControlObject::getInteger(obj, &timeout_);
+    if (!N_SUCCEEDED(error))
+    {
+        return error;
+    }
+    return NATIVE_ERROR_OK;
+}
+
+PROP_SETGET(getTimeout)
+int NativeHttpClientObject::getTimeout(TiObject* obj, void* /*userContext*/)
+{
+    obj->setValue(Number::New(timeout_));
+    return NATIVE_ERROR_OK;
+}
+
+
+PROP_SETGET(setOnLoadCallback)
+int NativeHttpClientObject::setOnLoadCallback(TiObject* obj, void* userContext)
+{
+    Handle<Value> value = obj->getValue();
+    if (value->IsFunction())
+    {
+    	TiHttpClientObject* context = (TiHttpClientObject*)userContext;
+        Handle<Object> source = Handle<Object>::Cast(context->getValue());
+        TiV8Event* connectEvent = TiV8Event::createEvent("onLoad", Handle<Function>::Cast(value), source);
+        setEventHandler("onLoad", connectEvent);
+        connectEvent->release();
+        return NATIVE_ERROR_OK;
+    }
+    return NATIVE_ERROR_INVALID_ARG;
+}
+
+PROP_SETGET(getOnLoadCallback)
+int NativeHttpClientObject::getOnLoadCallback(TiObject* /*obj*/, void* /*userContext*/)
+{
+    // TODO: Implement this function
+    return NATIVE_ERROR_NOTSUPPORTED;
+}
+
+PROP_SETGET(setOnErrorCallback)
+int NativeHttpClientObject::setOnErrorCallback(TiObject* obj, void* userContext)
+{
+    Handle<Value> value = obj->getValue();
+    if (value->IsFunction())
+    {
+    	TiHttpClientObject* context = (TiHttpClientObject*)userContext;
+        Handle<Object> source = Handle<Object>::Cast(context->getValue());
+        TiV8Event* connectEvent = TiV8Event::createEvent("onError", Handle<Function>::Cast(value), source);
+        setEventHandler("onError", connectEvent);
+        connectEvent->release();
+        return NATIVE_ERROR_OK;
+    }
+    return NATIVE_ERROR_INVALID_ARG;
+}
+
+PROP_SETGET(getOnErrorCallback)
+int NativeHttpClientObject::getOnErrorCallback(TiObject* /*obj*/, void* /*userContext*/)
+{
+    // TODO: Implement this function
+    return NATIVE_ERROR_NOTSUPPORTED;
+}
+
+const static NATIVE_PROPSETGET_SETTING g_HttpClientPropSetGet[] =
+{
+    {N_HTTP_CLIENT_SECURE_SERT, PROP_SETGET_FUNCTION(setValidateSecureSertificate), PROP_SETGET_FUNCTION(getValidateSecureSertificate)},
+    {N_HTTP_CLIENT_TIMEOUT, PROP_SETGET_FUNCTION(setTimeout), PROP_SETGET_FUNCTION(getTimeout)},
+    {N_HTTP_CLIENT_ONLOAD, PROP_SETGET_FUNCTION(setOnLoadCallback), PROP_SETGET_FUNCTION(getOnLoadCallback)},
+    {N_HTTP_CLIENT_ONERROR, PROP_SETGET_FUNCTION(setOnErrorCallback), PROP_SETGET_FUNCTION(getOnErrorCallback)}
+};
+
+static SetGetHTTPClientProperties g_HttpClientProps(g_HttpClientPropSetGet, GET_ARRAY_SIZE(g_HttpClientPropSetGet));
+
+int NativeHttpClientObject::setPropertyValue(size_t propertyNumber, TiObject* obj, void* userContext)
+{
+    NATIVE_PROPSETGET_CALLBACK cb = g_HttpClientProps.GetSetterCallback(propertyNumber);
+    if (cb == NULL)
+    {
+        return NATIVE_ERROR_NOTSUPPORTED;
+    }
+    return (cb)(this, obj, userContext);
+}
+
+int NativeHttpClientObject::getPropertyValue(size_t propertyNumber, TiObject* obj, void* userContext)
+{
+    NATIVE_PROPSETGET_CALLBACK cb = g_HttpClientProps.GetGetterCallback(propertyNumber);
+    if (cb == NULL)
+    {
+        return NATIVE_ERROR_NOTSUPPORTED;
+    }
+    return (cb)(this, obj, userContext);
+}
+
+
+NativeHttpClientObject::NativeHttpClientObject() :
+    networkManager_(new QNetworkAccessManager()),
+    operation_(QNetworkAccessManager::UnknownOperation),
+    url_(NULL),
+    replyHandler_(NULL),
+    validateSecureSert_(false),
+    timeout_(-1),
+    eventContainer_(NULL)
+{
+
+}
+
+NativeHttpClientObject::~NativeHttpClientObject()
+{
+   delete url_;
+   delete replyHandler_;
+   delete eventContainer_;
+}
+
+int NativeHttpClientObject::getObjectType() const
+{
+    return N_TYPE_HTTPCLIENT;
+}
+
+NativeHttpClientObject* NativeHttpClientObject::createHttpClient()
+{
+    return new NativeHttpClientObject;
+}
+
+void NativeHttpClientObject::setupEvents(TiEventContainerFactory* containerFactory)
+{
+    NativeProxyObject::setupEvents(containerFactory);
+    if (eventContainer_ == NULL)
+    {
+        eventContainer_ = containerFactory->createEventContainer();
+    }
+    replyHandler_ = new ReplyHandler(this, eventContainer_);
+    events_.insert("onLoad", EventPairSmartPtr(eventContainer_, replyHandler_));
+    events_.insert("onError", EventPairSmartPtr(eventContainer_, replyHandler_));
+}
+
+void NativeHttpClientObject::open(std::string method, std::string url)
+{
+	if (method == "GET")
+	{
+		operation_ = QNetworkAccessManager::GetOperation;
+	}
+	else if (method == "POST")
+	{
+		operation_ = QNetworkAccessManager::PostOperation;
+	}
+	else
+	{
+		//TODO
+	}
+    url_ = new QUrl(QString(url.c_str()));
+}
+
+void NativeHttpClientObject::send(std::string data)
+{
+   Q_ASSERT(networkManager_);
+
+   if (url_ == NULL)
+   {
+       //httpClient.send was called before calling httpClient.open
+	   return;
+   }
+
+   QNetworkRequest request(*url_);
+   QNetworkReply *reply;
+   switch (operation_)
+   {
+   case QNetworkAccessManager::GetOperation:
+	   reply = networkManager_->get(request);
+	   break;
+   case QNetworkAccessManager::PostOperation:
+	   reply = networkManager_->post(request, QByteArray(data.c_str()));
+	   break;
+   default:
+	   return;
+   }
+   QObject::connect(reply, SIGNAL(finished()), replyHandler_, SLOT(reply()));
+}
diff --git a/blackberry/tibb/NativeHttpClientObject.h b/blackberry/tibb/NativeHttpClientObject.h
new file mode 100644
index 0000000..2bd9938
--- /dev/null
+++ b/blackberry/tibb/NativeHttpClientObject.h
@@ -0,0 +1,114 @@
+/**
+ * Appcelerator Titanium Mobile
+ * Copyright (c) 2009-2012 by Appcelerator, Inc. All Rights Reserved.
+ * Licensed under the terms of the Apache Public License
+ * Please see the LICENSE included with this distribution for details.
+ */
+
+#ifndef NATIVEHTTPCLIENTOBJECT_H_
+#define NATIVEHTTPCLIENTOBJECT_H_
+
+#include "NativeProxyObject.h"
+#include <Qt/qnetworkaccessmanager.h>
+#include <string>
+#include <qobject.h>
+#include <Qt/qnetworkreply.h>
+#include "TiEventContainer.h"
+
+class TiObject;
+class TiEventContainerFactory;
+class QUrl;
+class NativeHttpClientObject;
+class ReplyHandler;
+
+enum NATIVE_HTTP_CLIENT_PROP
+{
+    N_HTTP_CLIENT_PROP_UNDEFINED
+    , N_HTTP_CLIENT_SECURE_SERT
+    , N_HTTP_CLIENT_TIMEOUT
+    , N_HTTP_CLIENT_ONLOAD
+    , N_HTTP_CLIENT_ONERROR
+
+    /* This MUST be the last element */
+    , N_HTTP_CLIENT_PROP_LAST
+};
+
+/**
+ * NativeHttpClientObject
+ */
+
+class NativeHttpClientObject : public NativeProxyObject
+{
+public:
+    static NativeHttpClientObject* createHttpClient();
+    int getObjectType() const;
+    void setupEvents(TiEventContainerFactory* containerFactory);
+    void open(std::string method, std::string url);
+    void send(std::string data);
+    int setPropertyValue(size_t propertyNumber, TiObject* obj, void* userContext);
+    int getPropertyValue(size_t propertyNumber, TiObject* obj, void* userContext);
+
+    //Properties
+    int setValidateSecureSertificate(TiObject* obj, void* /*userContext*/);
+    int getValidateSecureSertificate(TiObject* obj, void* /*userContext*/);
+    int setTimeout(TiObject* obj, void* /*userContext*/);
+    int getTimeout(TiObject* obj, void* /*userContext*/);
+    int setOnLoadCallback(TiObject* obj, void* userContext);
+    int getOnLoadCallback(TiObject* /*obj*/, void* /*userContext*/);
+    int setOnErrorCallback(TiObject* obj, void* userContext);
+    int getOnErrorCallback(TiObject* /*obj*/, void* /*userContext*/);
+
+protected:
+    virtual ~NativeHttpClientObject();
+
+private:
+    NativeHttpClientObject();
+    NativeHttpClientObject(const NativeHttpClientObject&);
+    NativeHttpClientObject& operator=(const NativeHttpClientObject&);
+
+    //TODO: probably this instance should be one per application (needs to understand)
+    QNetworkAccessManager* networkManager_;
+    QNetworkAccessManager::Operation operation_;
+    QUrl* url_;
+    ReplyHandler* replyHandler_;
+    bool validateSecureSert_;
+    int timeout_;
+    TiEventContainer* eventContainer_;
+};
+
+class ReplyHandler : public QObject
+{
+	Q_OBJECT
+
+public:
+    ReplyHandler(NativeHttpClientObject* owner, TiEventContainer* eventContainer)
+       : owner_ (owner)
+       , eventContainer_(eventContainer)
+    {
+    }
+
+public slots:
+    void reply()
+    {
+       QNetworkReply *reply = qobject_cast<QNetworkReply*>(sender());
+
+      if (reply) {
+           if ((reply->error()) == QNetworkReply::NoError) {
+               //read data from reply
+        	   QByteArray ar = reply->readAll();
+        	   eventContainer_->fireEvent();
+           } else {
+               //get http status code
+               int httpStatus = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
+           }
+           reply->deleteLater();
+       }
+    }
+
+private:
+    NativeHttpClientObject* owner_;
+    TiEventContainer* eventContainer_;
+};
+
+
+#endif /* NATIVEHTTPCLIENTOBJECT_H_ */
diff --git a/blackberry/tibb/NativeObject.h b/blackberry/tibb/NativeObject.h
index d838fa9..dcae530 100644
--- a/blackberry/tibb/NativeObject.h
+++ b/blackberry/tibb/NativeObject.h
@@ -28,6 +28,7 @@ enum NATIVE_TYPE
     , N_TYPE_CONTAINER
     , N_TYPE_DATE_TIME_PICKER
     , N_TYPE_DROPDOWN
+    , N_TYPE_HTTPCLIENT
     , N_TYPE_IMAGEVIEW
     , N_TYPE_LABEL
     , N_TYPE_LIST_VIEW
diff --git a/blackberry/tibb/NativeObjectFactory.cpp b/blackberry/tibb/NativeObjectFactory.cpp
index ad90a7d..3c9aad5 100644
--- a/blackberry/tibb/NativeObjectFactory.cpp
+++ b/blackberry/tibb/NativeObjectFactory.cpp
@@ -13,6 +13,7 @@
 #include "NativeButtonObject.h"
 #include "NativeDateTimePickerObject.h"
 #include "NativeDropDownObject.h"
+#include "NativeHttpClientObject.h"
 #include "NativeImageViewObject.h"
 #include "NativeLabelObject.h"
 #include "NativeListViewObject.h"
@@ -79,6 +80,10 @@ NativeObject* NativeObjectFactory::createNativeObject(int type)
         obj = new NativeButtonObject;
         break;
 
+    case N_TYPE_HTTPCLIENT:
+        obj = NativeHttpClientObject::createHttpClient();
+        break;
+
     case N_TYPE_SLIDER:
         obj = new NativeSliderObject;
         break;
diff --git a/blackberry/tibb/TiHttpClientObject.cpp b/blackberry/tibb/TiHttpClientObject.cpp
new file mode 100644
index 0000000..4971d8a
--- /dev/null
+++ b/blackberry/tibb/TiHttpClientObject.cpp
@@ -0,0 +1,187 @@
+/**
+ * Appcelerator Titanium Mobile
+ * Copyright (c) 2009-2012 by Appcelerator, Inc. All Rights Reserved.
+ * Licensed under the terms of the Apache Public License
+ * Please see the LICENSE included with this distribution for details.
+ */
+
+/**
+ * Appcelerator Titanium Mobile
+ * Copyright (c) 2009-2012 by Appcelerator, Inc. All Rights Reserved.
+ * Licensed under the terms of the Apache Public License
+ * Please see the LICENSE included with this distribution for details.
+ */
+
+#include "TiHttpClientObject.h"
+#include "TiGenericFunctionObject.h"
+#include "NativeHttpClientObject.h"
+#include "TiPropertyMapObject.h"
+#include "TiPropertySetFunctionObject.h"
+#include "TiPropertyGetFunctionObject.h"
+#include <string>
+
+const static TiProperty g_tiProperties[] =
+{
+    {
+        "validatesSecureCertificate", TI_PROP_PERMISSION_READ | TI_PROP_PERMISSION_WRITE, N_HTTP_CLIENT_SECURE_SERT
+    },
+
+    {
+        "timeout", TI_PROP_PERMISSION_READ | TI_PROP_PERMISSION_WRITE, N_HTTP_CLIENT_TIMEOUT
+    },
+
+    {
+        "onLoad", TI_PROP_PERMISSION_READ | TI_PROP_PERMISSION_WRITE, N_HTTP_CLIENT_ONLOAD
+    },
+
+    {
+        "onError", TI_PROP_PERMISSION_READ | TI_PROP_PERMISSION_WRITE, N_HTTP_CLIENT_ONERROR
+    },
+};
+
+TiHttpClientObject::TiHttpClientObject()
+    : TiProxy("")
+{
+}
+
+TiHttpClientObject::~TiHttpClientObject()
+{
+}
+
+void TiHttpClientObject::addObjectToParent(TiObject* parent)
+{
+	TiHttpClientObject* obj = new TiHttpClientObject;
+    parent->addMember(obj);
+    obj->release();
+}
+
+TiHttpClientObject* TiHttpClientObject::createHttpClient(NativeObjectFactory* objectFactory)
+{
+	TiHttpClientObject* obj = new TiHttpClientObject();
+    obj->setNativeObjectFactory(objectFactory);
+    obj->initializeTiObject(NULL);
+    return obj;
+}
+
+void TiHttpClientObject::initializeTiObject(TiObject* parentContext)
+{
+    if (!isInitialized())
+    {
+        TiProxy::initializeTiObject(parentContext);
+        NativeObject* obj = getNativeObjectFactory()->createNativeObject(N_TYPE_HTTPCLIENT);
+        setNativeObject(obj);
+        obj->release();
+    }
+}
+
+void TiHttpClientObject::onCreateStaticMembers()
+{
+    TiProxy::onCreateStaticMembers();
+    setTiMappingProperties(g_tiProperties, sizeof(g_tiProperties) / sizeof(*g_tiProperties));
+    TiGenericFunctionObject::addGenericFunctionToParent(this, "open", this, _open);
+    TiGenericFunctionObject::addGenericFunctionToParent(this, "send", this, _send);
+}
+
+void TiHttpClientObject::setTiMappingProperties(const TiProperty* props, int propertyCount)
+{
+    string name;
+    char c[2];
+    c[1] = 0;
+    for (int i = 0; i < propertyCount; i++)
+    {
+        TiObject* value = TiPropertyMapObject::addProperty(this, props[i].propertyName, props[i].nativePropertyNumber,
+                          _valueModify, _getValue, this);
+        // For all properties that have write permissions, add a setter method, e.g., myLabel.text=<my text>; myLabel.setText(<my text>);
+        if (props[i].permissions & TI_PROP_PERMISSION_WRITE)
+        {
+            c[0] = toupper(props[i].propertyName[0]);
+            name = "set";
+            name += c;
+            name += props[i].propertyName + 1;
+            TiPropertySetFunctionObject::addPropertySetter(this, value, name.c_str());
+        }
+        // For all properties that have read permissions, add a getter method, e.g., var test=myLabel.text; var test=myLabel.getText();
+        if (props[i].permissions & TI_PROP_PERMISSION_READ)
+        {
+            c[0] = toupper(props[i].propertyName[0]);
+            name = "get";
+            name += c;
+            name += props[i].propertyName + 1;
+            TiPropertyGetFunctionObject::addPropertyGetter(this, value, name.c_str());
+        }
+        value->release();
+    }
+}
+
+VALUE_MODIFY TiHttpClientObject::_valueModify(int propertyNumber, TiObject* value, void* context)
+{
+	TiHttpClientObject* self = (TiHttpClientObject*) context;
+    NativeHttpClientObject* object = (NativeHttpClientObject*)self->getNativeObject();
+    if (object == NULL)
+    {
+        return VALUE_MODIFY_NOT_SUPPORTED;
+    }
+    VALUE_MODIFY modify = VALUE_MODIFY_ALLOW;
+    switch (object->setPropertyValue(propertyNumber, value, self))
+    {
+    case NATIVE_ERROR_OK:
+        modify = VALUE_MODIFY_ALLOW;
+        break;
+    case NATIVE_ERROR_NOTSUPPORTED:
+        modify = VALUE_MODIFY_NOT_SUPPORTED;
+        break;
+    default:
+        modify = VALUE_MODIFY_INVALID;
+        break;
+    }
+    object->release();
+    return modify;
+}
+
+Handle<Value> TiHttpClientObject::_getValue(int propertyNumber, void* context)
+{
+	TiHttpClientObject* self = (TiHttpClientObject*) context;
+    NativeHttpClientObject* object = (NativeHttpClientObject*)self->getNativeObject();
+    TiObject value;
+    if (object != NULL)
+    {
+        object->getPropertyValue(propertyNumber, &value, context);
+    }
+    return value.getValue();
+}
+
+Handle<Value> TiHttpClientObject::_open(void* userContext, TiObject* /* caller */, const Arguments& args)
+{
+    HandleScope handleScope;
+    TiHttpClientObject* obj = (TiHttpClientObject*) userContext;
+    NativeHttpClientObject* nHttp = (NativeHttpClientObject*) obj->getNativeObject();
+    if (args.Length() > 1)
+    {
+        Handle<String> arg1 = args[0]->ToString();
+        Handle<String> arg2 = args[1]->ToString();
+        std::string method = *String::Utf8Value(arg1);
+        std::string url = *String::Utf8Value(arg2);
+        nHttp->open(method, url);
+    }
+    return Undefined();
+}
+
+Handle<Value> TiHttpClientObject::_send(void* userContext, TiObject* /* caller */, const Arguments& args)
+{
+	HandleScope handleScope;
+    TiHttpClientObject* obj = (TiHttpClientObject*) userContext;
+    NativeHttpClientObject* nHttp = (NativeHttpClientObject*) obj->getNativeObject();
+    std::string data;
+    if (args.Length() == 1)
+    {
+        Handle<String> arg1 = args[0]->ToString();
+        data = *String::Utf8Value(arg1);
+    }
+    nHttp->send(data);
+    return Undefined();
+}
+
+
+
+
+
diff --git a/blackberry/tibb/TiHttpClientObject.h b/blackberry/tibb/TiHttpClientObject.h
new file mode 100644
index 0000000..61b3d1d
--- /dev/null
+++ b/blackberry/tibb/TiHttpClientObject.h
@@ -0,0 +1,45 @@
+/**
+ * Appcelerator Titanium Mobile
+ * Copyright (c) 2009-2012 by Appcelerator, Inc. All Rights Reserved.
+ * Licensed under the terms of the Apache Public License
+ * Please see the LICENSE included with this distribution for details.
+ */
+
+#ifndef TIHTTPCLIENTOBJECT_H_
+#define TIHTTPCLIENTOBJECT_H_
+
+#include "TiProxy.h"
+
+/*
+ * TiHttpClientObject
+ *
+ * Implements HTTPClient interface
+ *
+ * Titanium.Network namespace
+ */
+
+class TiHttpClientObject : public TiProxy
+{
+public:
+    static void addObjectToParent(TiObject* parent);
+    static TiHttpClientObject* createHttpClient(NativeObjectFactory* objectFactory);
+    virtual void setTiMappingProperties(const TiProperty* prop, int propertyCount);
+
+protected:
+    virtual ~TiHttpClientObject();
+    virtual void onCreateStaticMembers();
+    virtual void initializeTiObject(TiObject* parentContext);
+
+private:
+    static VALUE_MODIFY _valueModify(int propertyNumber, TiObject* value, void* context);
+    static Handle<Value> _getValue(int propertyNumber, void* context);
+    static Handle<Value> _open(void* userContext, TiObject* caller, const Arguments& args);
+    static Handle<Value> _send(void* userContext, TiObject* caller, const Arguments& args);
+
+    TiHttpClientObject();
+    TiHttpClientObject(const TiHttpClientObject&);
+    TiHttpClientObject& operator=(const TiHttpClientObject&);
+};
+
+
+#endif /* TIHTTPCLIENTOBJECT_H_ */
diff --git a/blackberry/tibb/TiNetwork.cpp b/blackberry/tibb/TiNetwork.cpp
index 8765cd3..4b9b805 100644
--- a/blackberry/tibb/TiNetwork.cpp
+++ b/blackberry/tibb/TiNetwork.cpp
@@ -7,6 +7,8 @@
 
 #include "TiNetwork.h"
 
+#include "TiGenericFunctionObject.h"
+#include "TiHttpClientObject.h"
 #include "TiSocketObject.h"
 
 TiNetwork::TiNetwork()
@@ -36,5 +38,23 @@ void TiNetwork::onCreateStaticMembers()
 {
     TiProxy::onCreateStaticMembers();
     TiSocketObject::addObjectToParent(this, objectFactory_);
+    TiGenericFunctionObject::addGenericFunctionToParent(this, "createHTTPClient", this, _createHttpClient);
     // TODO: Add class methods, constants, properties
 }
+
+Handle<Value> TiNetwork::_createHttpClient(void* userContext, TiObject*, const Arguments& args)
+{
+    HandleScope handleScope;
+    TiNetwork* obj = (TiNetwork*) userContext;
+    Handle<ObjectTemplate> global = getObjectTemplateFromJsObject(args.Holder());
+    Handle<Object> result = global->NewInstance();
+    TiHttpClientObject* httpClient = TiHttpClientObject::createHttpClient(obj->objectFactory_);
+    httpClient->setValue(result);
+    if ((args.Length() > 0) && (args[0]->IsObject()))
+    {
+        Local<Object> settingsObj = Local<Object>::Cast(args[0]);
+        httpClient->setParametersFromObject(httpClient, settingsObj);
+    }
+    setTiObjectToJsObject(result, httpClient);
+    return handleScope.Close(result);
+}
diff --git a/blackberry/tibb/TiNetwork.h b/blackberry/tibb/TiNetwork.h
index 4ed3463..d7227bc 100644
--- a/blackberry/tibb/TiNetwork.h
+++ b/blackberry/tibb/TiNetwork.h
@@ -30,6 +30,8 @@ protected:
     virtual void onCreateStaticMembers();
 
 private:
+    static Handle<Value> _createHttpClient(void* userContext, TiObject*, const Arguments& args);
+
     TiNetwork();
     explicit TiNetwork(NativeObjectFactory* objectFactory);
     TiNetwork(const TiNetwork&);
diff --git a/blackberry/tibbtest/app.js b/blackberry/tibbtest/app.js
index c8fe5fc..8bb994c 100644
--- a/blackberry/tibbtest/app.js
+++ b/blackberry/tibbtest/app.js
@@ -15,110 +15,26 @@ var label1 = Ti.UI.createLabel({
 	top: 200
 });
 
-var label2 = Ti.UI.createLabel({
-	textAlign : 'center',
-	font: {fontSize:20},
-	color:'blue',
-	top: 0,
-	text: 'ZIndex',
-});
-
-win1.add(label1);
-win1.add(label2);
-
-var mybutton=Ti.UI.createButton
-(
-	{top: 100,title: 'Push Me'}
-);
-
-mybutton.addEventListener
-(
-	'click',
-	function(e)
-	{
-		e.source.title='Pushed!';
-		testbutton1.zIndex=15;
-	}
-);
-
-win1.add(mybutton);
-
-var slider1=Ti.UI.createSlider
-(
-	{
-		top: 200,
-		min: 0,
-		max: 100,
-		value: 50,
-	}
-);
 
-var sliderListener=function(e)
-{
-	progress1.value=100-e.value;
-	label1.text='Slider value: '+e.value;
-	label1.top=e.value;
-	mybutton.opacity=e.value/100.0;
-	mybutton.left=e.value;
-	mybutton.top=e.value;
-};
-
-slider1.addEventListener('change',sliderListener);
-label1.addEventListener('click',function(e)
-	{
-		label1.text='Label was clicked';
-	}
-	);
-
-
-win1.add(slider1);
-
-var progress1=Ti.UI.createProgressBar({
-	value:0,
-	min: 0,
-	max: 100,
-	top: 300,
+var client = Ti.Network.createHTTPClient({
+validatesSecureCertificate: true,
+timeout: 100,
+     onLoad : function(e) {
+             Ti.API.info("onLoad is called!");
+     },
+     onError : function(e) {
+             Ti.API.info("onError is called!");
+     },
 });
 
-win1.add(progress1);
+Ti.API.info("Timeout: " + client.getTimeout());
+Ti.API.info("Sec Sert: " + client.getValidatesSecureCertificate());
 
-var testbutton1=Ti.UI.createButton
-(
-	{top: 500,left:0,title: 'Button 1',zIndex:0}
-);
-win1.add(testbutton1);
+var url = "http://www.appcelerator.com";
 
-var testbutton2=Ti.UI.createButton
-(
-	{top: 550,left:50,title: 'Button 2',zIndex:20}
-);
-win1.add(testbutton2);
+client.open("GET", url);
+client.send();
 
-var testbutton3=Ti.UI.createButton
-(
-	{top: 600,left:100,title: 'Button 3',zIndex:25}
-);
-win1.add(testbutton3);
 
-var testbutton4=Ti.UI.createButton
-(
-	{top: 650,left:150,title: 'Button 4',zIndex:10}
-);
-win1.add(testbutton4);
-
-// open window
-win1.open();
-
-var timer=setInterval(function()
-{
-	label2.text='ZIndex of button1='+testbutton1.zIndex+', Zindex of button2='+testbutton2.zIndex;
-	testbutton1.top=500+Math.floor(Math.random()*500);
-	testbutton1.left=Math.floor(Math.random()*500);
-	testbutton2.top=500+Math.floor(Math.random()*500);
-	testbutton2.left=Math.floor(Math.random()*500);
-	testbutton3.top=500+Math.floor(Math.random()*500);
-	testbutton3.left=Math.floor(Math.random()*500);
-	testbutton4.top=500+Math.floor(Math.random()*500);
-	testbutton4.left=Math.floor(Math.random()*500);
-},5000
-);
\ No newline at end of file
+win1.add(label1);
+win1.open();
\ No newline at end of file
