Merge lp:~gary-wzl77/storage-provider-onedrive/upload into lp:storage-provider-onedrive/devel

[Gary.Wang]

Simple upload done. Support to upload content less than 100mb.

Simple upload done. Support to upload content less than 100mb.

[unity-api-1-bot (unity-api-1-bot)]

FAILED: Continuous integration, rev:9
https://jenkins.canonical.com/unity-api-1/job/lp-storage-provider-onedrive-ci/1/
Executed test runs:
    FAILURE: https://jenkins.canonical.com/unity-api-1/job/build/804/console
    FAILURE: https://jenkins.canonical.com/unity-api-1/job/build-0-fetch/810/console

Click here to trigger a rebuild:
https://jenkins.canonical.com/unity-api-1/job/lp-storage-provider-onedrive-ci/1/rebuild

review: Needs Fixing (continuous-integration)

[unity-api-1-bot (unity-api-1-bot)]

FAILED: Continuous integration, rev:9
https://jenkins.canonical.com/unity-api-1/job/lp-storage-provider-onedrive-ci/2/
Executed test runs:
    FAILURE: https://jenkins.canonical.com/unity-api-1/job/build/818/console
    FAILURE: https://jenkins.canonical.com/unity-api-1/job/build-0-fetch/824/console

Click here to trigger a rebuild:
https://jenkins.canonical.com/unity-api-1/job/lp-storage-provider-onedrive-ci/2/rebuild

review: Needs Fixing (continuous-integration)

[lp:~gary-wzl77/storage-provider-onedrive/upload]

10. By Gary.Wang on 2016-09-30

debian file fixes.

11. By Gary.Wang on 2016-09-30

merge from devel and resolve the conflict.

[unity-api-1-bot (unity-api-1-bot)]

FAILED: Continuous integration, rev:11
https://jenkins.canonical.com/unity-api-1/job/lp-storage-provider-onedrive-ci/3/
Executed test runs:
    FAILURE: https://jenkins.canonical.com/unity-api-1/job/build/820/console
    FAILURE: https://jenkins.canonical.com/unity-api-1/job/build-0-fetch/827/console

Click here to trigger a rebuild:
https://jenkins.canonical.com/unity-api-1/job/lp-storage-provider-onedrive-ci/3/rebuild

review: Needs Fixing (continuous-integration)

[lp:~gary-wzl77/storage-provider-onedrive/upload]

12. By Gary.Wang on 2016-09-30

support split mode for builddeb.

[unity-api-1-bot (unity-api-1-bot)]

FAILED: Continuous integration, rev:12
https://jenkins.canonical.com/unity-api-1/job/lp-storage-provider-onedrive-ci/4/
Executed test runs:
    FAILURE: https://jenkins.canonical.com/unity-api-1/job/build/822/console
    SUCCESS: https://jenkins.canonical.com/unity-api-1/job/build-0-fetch/829
    FAILURE: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=amd64,release=vivid+overlay/632/console
    FAILURE: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=amd64,release=xenial+overlay/632/console
    FAILURE: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=amd64,release=yakkety/632/console
    FAILURE: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=armhf,release=vivid+overlay/632/console
    FAILURE: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=armhf,release=xenial+overlay/632/console
    FAILURE: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=armhf,release=yakkety/632/console
    FAILURE: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=i386,release=vivid+overlay/632/console
    FAILURE: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=i386,release=xenial+overlay/632/console
    FAILURE: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=i386,release=yakkety/632/console

Click here to trigger a rebuild:
https://jenkins.canonical.com/unity-api-1/job/lp-storage-provider-onedrive-ci/4/rebuild

review: Needs Fixing (continuous-integration)

[lp:~gary-wzl77/storage-provider-onedrive/upload]

13. By Gary.Wang on 2016-09-30

add cmake-extras package.

[unity-api-1-bot (unity-api-1-bot)]

FAILED: Continuous integration, rev:13
https://jenkins.canonical.com/unity-api-1/job/lp-storage-provider-onedrive-ci/5/
Executed test runs:
    FAILURE: https://jenkins.canonical.com/unity-api-1/job/build/823/console
    SUCCESS: https://jenkins.canonical.com/unity-api-1/job/build-0-fetch/830
    FAILURE: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=amd64,release=vivid+overlay/633/console
    FAILURE: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=amd64,release=xenial+overlay/633/console
    FAILURE: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=amd64,release=yakkety/633/console
    FAILURE: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=armhf,release=vivid+overlay/633/console
    FAILURE: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=armhf,release=xenial+overlay/633/console
    FAILURE: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=armhf,release=yakkety/633/console
    FAILURE: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=i386,release=vivid+overlay/633/console
    FAILURE: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=i386,release=xenial+overlay/633/console
    FAILURE: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=i386,release=yakkety/633/console

Click here to trigger a rebuild:
https://jenkins.canonical.com/unity-api-1/job/lp-storage-provider-onedrive-ci/5/rebuild

review: Needs Fixing (continuous-integration)

[lp:~gary-wzl77/storage-provider-onedrive/upload]

14. By Gary.Wang on 2016-09-30

some changes to make CI feels good.

[unity-api-1-bot (unity-api-1-bot)]

FAILED: Continuous integration, rev:14
https://jenkins.canonical.com/unity-api-1/job/lp-storage-provider-onedrive-ci/6/
Executed test runs:
    FAILURE: https://jenkins.canonical.com/unity-api-1/job/build/824/console
    SUCCESS: https://jenkins.canonical.com/unity-api-1/job/build-0-fetch/831
    FAILURE: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=amd64,release=vivid+overlay/634/console
    SUCCESS: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=amd64,release=xenial+overlay/634
        deb: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=amd64,release=xenial+overlay/634/artifact/output/*zip*/output.zip
    SUCCESS: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=amd64,release=yakkety/634
        deb: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=amd64,release=yakkety/634/artifact/output/*zip*/output.zip
    FAILURE: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=armhf,release=vivid+overlay/634/console
    SUCCESS: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=armhf,release=xenial+overlay/634
        deb: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=armhf,release=xenial+overlay/634/artifact/output/*zip*/output.zip
    SUCCESS: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=armhf,release=yakkety/634
        deb: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=armhf,release=yakkety/634/artifact/output/*zip*/output.zip
    FAILURE: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=i386,release=vivid+overlay/634/console
    SUCCESS: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=i386,release=xenial+overlay/634
        deb: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=i386,release=xenial+overlay/634/artifact/output/*zip*/output.zip
    SUCCESS: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=i386,release=yakkety/634
        deb: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=i386,release=yakkety/634/artifact/output/*zip*/output.zip

Click here to trigger a rebuild:
https://jenkins.canonical.com/unity-api-1/job/lp-storage-provider-onedrive-ci/6/rebuild

review: Needs Fixing (continuous-integration)

[lp:~gary-wzl77/storage-provider-onedrive/upload]

15. By Gary.Wang on 2016-09-30

remove http::header from async_get as it's not used anymore.

[unity-api-1-bot (unity-api-1-bot)]

PASSED: Continuous integration, rev:15
https://jenkins.canonical.com/unity-api-1/job/lp-storage-provider-onedrive-ci/7/
Executed test runs:
    SUCCESS: https://jenkins.canonical.com/unity-api-1/job/build/825
    SUCCESS: https://jenkins.canonical.com/unity-api-1/job/build-0-fetch/832
    SUCCESS: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=amd64,release=vivid+overlay/635
        deb: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=amd64,release=vivid+overlay/635/artifact/output/*zip*/output.zip
    SUCCESS: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=amd64,release=xenial+overlay/635
        deb: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=amd64,release=xenial+overlay/635/artifact/output/*zip*/output.zip
    SUCCESS: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=amd64,release=yakkety/635
        deb: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=amd64,release=yakkety/635/artifact/output/*zip*/output.zip
    SUCCESS: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=armhf,release=vivid+overlay/635
        deb: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=armhf,release=vivid+overlay/635/artifact/output/*zip*/output.zip
    SUCCESS: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=armhf,release=xenial+overlay/635
        deb: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=armhf,release=xenial+overlay/635/artifact/output/*zip*/output.zip
    SUCCESS: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=armhf,release=yakkety/635
        deb: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=armhf,release=yakkety/635/artifact/output/*zip*/output.zip
    SUCCESS: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=i386,release=vivid+overlay/635
        deb: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=i386,release=vivid+overlay/635/artifact/output/*zip*/output.zip
    SUCCESS: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=i386,release=xenial+overlay/635
        deb: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=i386,release=xenial+overlay/635/artifact/output/*zip*/output.zip
    SUCCESS: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=i386,release=yakkety/635
        deb: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=i386,release=yakkety/635/artifact/output/*zip*/output.zip

Click here to trigger a rebuild:
https://jenkins.canonical.com/unity-api-1/job/lp-storage-provider-onedrive-ci/7/rebuild

review: Approve (continuous-integration)

=== added directory '.bzr-builddeb'
=== added file '.bzr-builddeb/default.conf'
--- .bzr-builddeb/default.conf	1970-01-01 00:00:00 +0000
+++ .bzr-builddeb/default.conf	2016-09-30 08:26:58 +0000
@@ -0,0 +1,2 @@
+[BUILDDEB]
+split = True

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2016-09-26 04:27:03 +0000
+++ CMakeLists.txt	2016-09-30 08:26:58 +0000
@@ -16,7 +16,7 @@
 
 cmake_minimum_required(VERSION 2.8)
 
-project(onedrive)
+project(onedrive-provider)
 
 include(GNUInstallDirs)
 
@@ -26,9 +26,9 @@
 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11 -Werror -Wall -fno-strict-aliasing -fvisibility=hidden -fvisibility-inlines-hidden -pedantic -Wextra")
 set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -Wl,--no-undefined")
 
-set(ONEDRIVE_LIB_VERSION_MAJOR 0)
-set(ONEDRIVE_LIB_VERSION_MINOR 0)
-set(ONEDRIVE_LIB_VERSION_PATCH 1)
+set(ONEDRIVE_PROVIDER_LIB_VERSION_MAJOR 0)
+set(ONEDRIVE_PROVIDER_LIB_VERSION_MINOR 0)
+set(ONEDRIVE_PROVIDER_LIB_VERSION_PATCH 1)
 
 include(CTest)
 
@@ -36,7 +36,7 @@
   include/
 )
 
-file(GLOB_RECURSE ONEDRIVE_LIB_INTERFACE_HEADERS include/*.h)
+file(GLOB_RECURSE ONEDRIVE_PROVIDER_LIB_INTERFACE_HEADERS include/*.h)
 
 include(EnableCoverageReport)
 
@@ -45,11 +45,12 @@
 add_subdirectory(include)
 add_subdirectory(src)
 add_subdirectory(tests)
-add_subdirectory(provider)
+#add_subdirectory(provider)
 
 enable_coverage_report(
   TARGETS    
-    onedrive
+    onedrive-provider
+    #onedrive-provider-bin
   FILTER
     ${CMAKE_SOURCE_DIR}/test/*
     ${CMAKE_BINARY_DIR}/*

=== modified file 'data/CMakeLists.txt'
--- data/CMakeLists.txt	2016-09-26 04:27:03 +0000
+++ data/CMakeLists.txt	2016-09-30 08:26:58 +0000
@@ -15,10 +15,10 @@
 # Authored by: Gary Wang <[e-mail]>
 
 configure_file(
-  onedrive.pc.in onedrive.pc @ONLY
+  onedrive-provider.pc.in onedrive-provider.pc @ONLY
 )
 
 install(
-  FILES ${CMAKE_CURRENT_BINARY_DIR}/onedrive.pc
+  FILES ${CMAKE_CURRENT_BINARY_DIR}/onedrive-provider.pc
   DESTINATION ${CMAKE_INSTALL_LIBDIR}/pkgconfig
 )

=== added file 'data/onedrive-provider.pc.in'
--- data/onedrive-provider.pc.in	1970-01-01 00:00:00 +0000
+++ data/onedrive-provider.pc.in	2016-09-30 08:26:58 +0000
@@ -0,0 +1,10 @@
+prefix=@CMAKE_INSTALL_PREFIX@
+exec_prefix=${prefix}
+libdir=${exec_prefix}/lib
+includedir=${exec_prefix}/include
+ 
+Name: @CMAKE_PROJECT_NAME@
+Description: Cloud based content sharing library for Microsoft Onedrive service
+Version: @ONEDRIVE_LIB_VERSION_MAJOR@.@ONEDRIVE_LIB_VERSION_MINOR@.@ONEDRIVE_LIB_VERSION_PATCH@
+Libs: -L${libdir} -lonedrive
+Cflags: -I${includedir}

=== removed file 'data/onedrive.pc.in'
--- data/onedrive.pc.in	2016-09-26 04:27:03 +0000
+++ data/onedrive.pc.in	1970-01-01 00:00:00 +0000
@@ -1,10 +0,0 @@
-prefix=@CMAKE_INSTALL_PREFIX@
-exec_prefix=${prefix}
-libdir=${exec_prefix}/lib
-includedir=${exec_prefix}/include
- 
-Name: @CMAKE_PROJECT_NAME@
-Description: Cloud based content sharing library for Microsoft Onedrive service
-Version: @ONEDRIVE_LIB_VERSION_MAJOR@.@ONEDRIVE_LIB_VERSION_MINOR@.@ONEDRIVE_LIB_VERSION_PATCH@
-Libs: -L${libdir} -lonedrive
-Cflags: -I${includedir}

=== modified file 'debian/control'
--- debian/control	2016-09-30 05:26:58 +0000
+++ debian/control	2016-09-30 08:26:58 +0000
@@ -2,11 +2,12 @@
 Priority: optional
 Maintainer: Gary Wang <[e-mail]>
 Build-Depends: cmake,
+               cmake-extras (>= 0.4),
                debhelper (>= 9),
                doxygen,
                google-mock,
                graphviz,
-               libnet-cpp-dev,
+               libnet-cpp-dev (>= 2.0.0),
                libboost-dev (>= 1.58) | libboost1.58-dev,
                libboost-filesystem-dev (>= 1.58) | libboost-filesystem1.58-dev,
                libboost-system-dev (>= 1.58) | libboost-system1.58-dev,

=== modified file 'debian/onedrive-provider0.install'
--- debian/onedrive-provider0.install	2016-09-30 05:26:58 +0000
+++ debian/onedrive-provider0.install	2016-09-30 08:26:58 +0000
@@ -1,3 +1,1 @@
 usr/lib/*/lib*.so.*
-usr/bin/*
-usr/share/dbus-1/services/*

=== modified file 'doc/Doxyfile.in'
--- doc/Doxyfile.in	2016-09-26 04:27:03 +0000
+++ doc/Doxyfile.in	2016-09-30 08:26:58 +0000
@@ -32,13 +32,13 @@
 # This could be handy for archiving the generated documentation or
 # if some version control system is used.
 
-PROJECT_NUMBER         = @ONEDIRVE_LIB_VERSION_MAJOR@.@ONEDIRVE_LIB_VERSION_MINOR@.@ONEDIRVE_LIB_VERSION_PATCH@
+PROJECT_NUMBER         = @ONEDIRVE_PROVIDER_LIB_VERSION_MAJOR@.@ONEDIRVE_PROVIDER_LIB_VERSION_MINOR@.@ONEDIRVE_PROVIDER_LIB_VERSION_PATCH@
 
 # Using the PROJECT_BRIEF tag one can provide an optional one line description
 # for a project that appears at the top of each page and should give viewer
 # a quick idea about the purpose of the project. Keep the description short.
 
-PROJECT_BRIEF          = "Onedrive API library For Microsoft OneDrive Service"
+PROJECT_BRIEF          = "Onedrive API library For Microsoft OneDrive Service and a Storage Provider."
 
 # With the PROJECT_LOGO tag one can specify an logo or icon that is
 # included in the documentation. The maximum height of the logo should not

=== added file 'include/onedrive/api/client.h'
--- include/onedrive/api/client.h	1970-01-01 00:00:00 +0000
+++ include/onedrive/api/client.h	2016-09-30 08:26:58 +0000
@@ -0,0 +1,203 @@
+/*
+ * Copyright © 2016 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Gary Wang <[e-mail]>
+ */
+
+#ifndef ONEDRIVE_API_CLIENT_H_
+#define ONEDRIVE_API_CLIENT_H_
+
+#include <onedrive/api/visibility.h>
+#include <onedrive/api/taskqueue.h>
+#include <onedrive/api/storageinfo.h>
+#include <onedrive/api/cloudresource.h>
+#include <onedrive/api/clouditem.h>
+#include <onedrive/api/cloudfolder.h>
+#include <onedrive/api/downloadtask.h>
+#include <onedrive/api/uploadtask.h>
+#include <onedrive/api/syncmanager.h>
+
+#include <deque>
+
+namespace onedrive {
+namespace api {
+
+class ClientPriv;
+
+/*!
+    \class Client
+    \brief Onedrive API provides developer to easily access login user's cloud contents stored on microsoft onedrive service,
+    such as musics, movie, docs, images, and so on.
+
+    The API enable developers to
+        <list type="bullet">
+            <item>retrieve authorized user cloud content list.</item>
+            <item>create, delete, move and update cloud resources.</item>
+            <item>query content infomation.</item>
+            <item>create an extranet link to share.</item>
+            <item>upload a local content to onedrive.</item>
+            <item>download a content from onedrive.</item>
+        </list>
+
+    Also sync up manager will be running on the background when client is constructed. It handles over
+    local content upload and cloud item download. \sa syncmanager.
+
+    \note Onedrive API covers cloud resourece access and content sync-up between local and cloud. It does not take
+    responsibility of account authentication. So before using onedrive APIs, developers need to call \sa set_access_token to
+    manually set a valid access_token or \sa refresh_token to fetch access token,
+    which is used to call onedrive APIs internally to pass through authentication.
+ */
+
+class ONEDRIVE_API_DLL_PUBLIC Client {
+
+  public:
+    typedef std::shared_ptr<Client> Ptr;
+
+    typedef std::deque<CloudResource::Ptr>   ResourceList;
+
+    typedef std::vector<std::string>    Stringlist;
+
+    /*!
+     * \brief Constructs a onedrive Client object with \a request_timeout seconds.
+     * Meanwhile client launches sync-up manager to deal with task download and upload by default.
+     */
+    Client(int request_timeout = 10);
+
+    Client(const Client&) = delete;
+
+    Client& operator=(const Client&) = delete;
+
+    virtual ~Client();
+
+    /*!
+     * \brief Set \a access_token to authenticate all onedrive API calls with the bearer HTTP authorization scheme.
+     * The access token can be fetched through ubuntu sso services.
+     */
+    void set_access_token(const std::string &access_token);
+
+    /*!
+     * \brief Retrieves and refreshes access token by using \a refresh_token.
+     * The refresh token can be fetched through ubuntu sso services.
+     * \throw std::runtime_error if error occurs.
+     * \returns true if access token is refreshed, otherwise returns false.
+     */
+//    bool refresh_token(const std::string &refresh_token);
+
+    /*!
+     * \brief Returns login user's onedrive cloud storage information.
+     * \throw std::runtime_error if error occurs.
+     * @sa UserInfo
+     */
+    StorageInfo storage_info();
+
+    /*!
+     * \brief Returns root folder object on onedrive.
+     * \throw std::runtime_error if error occurs.
+     * \sa cloud_content_list(), storage_info()
+     */
+    CloudFolder::Ptr root_folder();
+
+    /*!
+     * \brief Returns cloud item list and next page token when querying one specific folder \a folder_id.
+     * if \a folder_id is empty, returns item list under root directory of onedrive.
+     * if \a page_token is empty, queries contents from the first page.
+     * The fetched content count is 200 at most per call.
+     * \a page_token indicates the specific page index on the onedrive.
+     * \throw std::runtime_error if error occurs.
+     * \sa root_folder(), metadata(), search()
+     */
+    std::tuple<ResourceList, std::string> cloud_content_list(const std::string &folder_id = std::string(),
+                                                             const std::string &page_token = std::string());
+
+    /*!
+     * \brief Returns a resouce item object if content with a given \a content_id can be found on onedrive.
+     * otherwise return nullptr.
+     * \throw std::runtime_error if error occurs.
+     * \sa cloud_content_list()
+     */
+    CloudResource::Ptr  metadata(const std::string & content_id);
+
+    /*!
+     * \brief Returns a folder item object if a folder \a folder_name is created under a given \a folder_id folder,
+     * otherwise return nullptr.
+     * if \a folder_id is empty, creates a folder item under root folder of onedrive.
+     * \throw std::runtime_error if error occurs.
+     * \sa delete_item(), move_item(), copy_item()
+     */
+    CloudFolder::Ptr    create_folder(const std::string &folder_name,
+                                      const std::string &folder_id = std::string());
+
+    /*!
+     * \brief Returns a cloud item list if there are available items that matches with \a name under a given \a folder_id folder.
+     * if \a folder_id is empty, searches items under root folder of onedrive.
+     * \throw std::runtime_error if error occurs.
+     * \sa delete_item(), metadata()
+     */
+    Client::ResourceList search(const std::string &name,
+                                const std::string &folder_id = std::string());
+
+    /*!
+     * \brief Returns true if content \a content_id is deleted, otherwise return false.
+     * \throw std::runtime_error if error occurs.
+     * \sa move_item(), metadata(), copy_item()
+     */
+    bool delete_item(const std::string &content_id);
+
+    /*!
+     * \brief Returns a resource item object if an item \a item_id is copies to a given folder \a folder_id with a new \a name on onedrive.
+     * otherwise return nullptr.
+     * \throw std::runtime_error if error occurs.
+     * \sa move_item(), update_folder(), delete_item()
+    CloudResource::Ptr copy_item(const std::string &item_id,
+                                 const std::string &name,
+                                 const std::string &folder_id);
+     */
+
+    /*!
+     * \brief Returns a resource item object if an item \a item_id is moved to a given folder \a folder_id on onedrive with new \a item_name .
+     * otherwise return nullptr.
+     * if item_name is empty, name will not changed after moving to a new folder.
+     * \throw std::runtime_error if error occurs.
+     * \sa move_item(), update_folder(), delete_item()
+     */
+    CloudResource::Ptr  move_item(const std::string &item_id,
+                                  const std::string &folder_id,
+                                  const std::string &item_name = std::string());
+
+    /*!
+     * \brief Returns a resource item object if an item \a item_id is updated with \a new name, otherwise return false.
+     * otherwise return nullptr.
+     * \throw std::runtime_error if error occurs.
+     * \sa delete_contents(), copy_folders(),
+     */
+    CloudResource::Ptr rename_item(const std::string &folder_id,
+                                   const std::string &new_folder_name);
+
+
+    /*!
+     * \brief Returns a sync-up manager running on the background.
+     * sync-up manager scheduled tasks \sa start, pause, cancel for content upload and download.
+     */
+    SyncManager::Ptr syncmanager() const;
+
+  private:
+    std::shared_ptr<ClientPriv>  p;
+
+};
+
+}
+}
+
+#endif // ONEDRIVE_API_CLIENT_H_

=== added file 'include/onedrive/api/cloudfolder.h'
--- include/onedrive/api/cloudfolder.h	1970-01-01 00:00:00 +0000
+++ include/onedrive/api/cloudfolder.h	2016-09-30 08:26:58 +0000
@@ -0,0 +1,111 @@
+/*
+ * Copyright © 2016 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Gary Wang <[e-mail]>
+ */
+
+#ifndef ONEDRIVE_API_CLOUDFOLDER_H_
+#define ONEDRIVE_API_CLOUDFOLDER_H_
+
+#include <onedrive/api/cloudresource.h>
+#include <onedrive/api/visibility.h>
+
+namespace Json {
+    class Value;
+}
+
+namespace onedrive {
+namespace api {
+
+/*!
+    \class CloudFolder
+    \brief CloudFolder represents a folder object on onedrive.
+ */
+
+class ONEDRIVE_API_DLL_PUBLIC CloudFolder : public CloudResource {
+public:
+    typedef std::shared_ptr<CloudFolder> Ptr;
+
+    virtual ~CloudFolder() = default;
+
+    /*!
+     * \brief Returns a unique id of cloud folder object.
+     */
+    const std::string &id() const override;
+
+    /*!
+     * \brief Returns the name of cloud folder object.
+     */
+    const std::string &name() const override;
+
+    /*!
+     * \brief Returns the datetime when folder was created.
+     */
+    const std::time_t &created_date() const override;
+
+    /*!
+     * \brief Returns the datetime when folder was updated.
+     */
+    const std::time_t &updated_date() const override;
+
+    /*!
+     * \brief Returns a shared link on onedriver for a folder .
+     */
+    const std::string &download_url() const override;
+
+    /*!
+     * \brief Returns a unique id of the parent folder.
+     */
+    const std::string &folder_id() const override;
+
+    /*!
+     * \brief Returns etag of a folder object.
+     */
+    const std::string &etag() const override;
+
+    /*!
+     * \brief Returns owner id of a folder object.
+     */
+    const std::string &owner() const override;
+
+    /*!
+     * \brief Returns resource property of an object.
+     * \sa CloudResource::Property
+     */
+    CloudResource::Property property() const override;
+
+    /*!
+     * \brief Returns a item' parent folder path on onedrive.
+     */
+    const std::string &folder_path() const override;
+
+    /*!
+     * \brief Returns the number of children items under this folder.
+     */
+    int children_count() const;
+
+private:
+    CloudFolder(const Json::Value &root);
+
+    friend class ClientPriv;
+
+    class Priv;
+    std::shared_ptr<Priv>   p;
+};
+
+}
+}
+
+#endif // ONEDRIVE_API_CLOUDFOLDER_H_

=== added file 'include/onedrive/api/clouditem.h'
--- include/onedrive/api/clouditem.h	1970-01-01 00:00:00 +0000
+++ include/onedrive/api/clouditem.h	2016-09-30 08:26:58 +0000
@@ -0,0 +1,123 @@
+/*
+ * Copyright © 2016 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Gary Wang <[e-mail]>
+ */
+
+#ifndef ONEDRIVE_API_CloudItem_H_
+#define ONEDRIVE_API_CloudItem_H_
+
+#include <onedrive/api/cloudresource.h>
+#include <onedrive/api/visibility.h>
+
+#include <unordered_map>
+
+namespace Json {
+    class Value;
+}
+
+namespace onedrive {
+namespace api {
+
+/*!
+    \class CloudItem
+    \brief CloudItem represents a item object on onedrive.
+ */
+
+class ONEDRIVE_API_DLL_PUBLIC CloudItem: public CloudResource {
+public:
+    typedef std::shared_ptr<CloudItem> Ptr;
+
+    virtual ~CloudItem() = default;
+
+    /*!
+     * \brief Returns a unique id of cloud item object.
+     */
+    const std::string &id() const override;
+
+    /*!
+     * \brief Returns the name of cloud item object.
+     */
+    const std::string &name() const override;
+
+    /*!
+     * \brief Returns the datetime when item was created.
+     */
+    const std::time_t &created_date() const override;
+
+    /*!
+     * \brief Returns the datetime when item was updated.
+     */
+    const std::time_t &updated_date() const override;
+
+    /*!
+     * \brief Returns a download link on onedriver for a item .
+     */
+    const std::string &download_url() const override;
+
+    /*!
+     * \brief Returns a item' parent folder id on onedrive.
+     */
+    const std::string &folder_id() const override;
+
+    /*!
+     * \brief Returns a item' parent folder path on onedrive.
+     */
+    const std::string &folder_path() const override;
+
+    /*!
+     * \brief Returns etag of a item object.
+     */
+    const std::string &etag() const override;
+
+    /*!
+     * \brief Returns owner id of a item object.
+     */
+    const std::string &owner() const override;
+
+    /*!
+     * \brief Returns resource type of an object.
+     */
+    CloudResource::Property property() const override;
+
+    /*!
+     * \brief Returns content size of an object in bytes.
+     */
+    int64_t size() const;
+
+    /*!
+     * \brief Returns item's mimetype.
+     */
+    const std::string &mimetype() const;
+
+    /*!
+     * \brief content specific metadata info.
+     */
+    std::unordered_map<std::string, std::string> &metadata() const;
+
+private:
+    CloudItem(const Json::Value &root);
+
+    friend class UploadTaskPriv;
+    friend class ClientPriv;
+
+    class Priv;
+    std::shared_ptr<Priv> p;
+};
+
+}
+}
+
+#endif // ONEDRIVE_API_CloudItem_H_

=== added file 'include/onedrive/api/cloudresource.h'
--- include/onedrive/api/cloudresource.h	1970-01-01 00:00:00 +0000
+++ include/onedrive/api/cloudresource.h	2016-09-30 08:26:58 +0000
@@ -0,0 +1,69 @@
+/*
+ * Copyright © 2016 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Gary Wang <[e-mail]>
+ */
+
+#ifndef ONEDRIVE_API_CLOUDRESOURCE_H_
+#define ONEDRIVE_API_CLOUDRESOURCE_H_
+
+#include <memory>
+#include <string>
+#include <ctime>
+
+namespace onedrive {
+namespace api {
+
+/*!
+    \class CloudResource
+    \brief CloudResource is an abstract object that provides common interfaces for CloudItem and CloudFolder.
+ */
+
+class CloudResource {
+  public:
+    typedef std::shared_ptr<CloudResource>  Ptr;
+
+    enum class Property {
+        Content,  ///< content resource
+        Folder    ///< folder resource
+    };
+
+    virtual ~CloudResource() = default;
+
+    virtual const std::string &id() const = 0;
+
+    virtual const std::string &name() const = 0;
+
+    virtual const std::time_t &created_date() const = 0;
+
+    virtual const std::time_t &updated_date() const = 0;
+
+    virtual const std::string &download_url() const = 0;
+
+    virtual const std::string &folder_id() const = 0;
+
+    virtual const std::string &folder_path() const = 0;
+
+    virtual const std::string &etag() const = 0;
+
+    virtual const std::string &owner() const = 0;
+
+    virtual Property property() const = 0;
+};
+
+}
+}
+
+#endif // ONEDRIVE_API_CLOUDRESOURCE_H_

=== added file 'include/onedrive/api/downloadtask.h'
--- include/onedrive/api/downloadtask.h	1970-01-01 00:00:00 +0000
+++ include/onedrive/api/downloadtask.h	2016-09-30 08:26:58 +0000
@@ -0,0 +1,119 @@
+/*
+ * Copyright © 2016 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Gary Wang <[e-mail]>
+ */
+
+#ifndef ONEDRIVE_API_DOWNLOADTASK_H_
+#define ONEDRIVE_API_DOWNLOADTASK_H_
+
+#include <onedrive/api/visibility.h>
+#include <onedrive/api/cloudresource.h>
+#include <onedrive/api/task.h>
+
+namespace onedrive {
+namespace api {
+
+class TaskHandler;
+
+/*!
+    \struct DownloadBufferCb
+    \brief DownloadBufferCb is a download request object which consists of a content id and
+    writing callback function allows content data can be received in buffering via callback function.
+ */
+struct ONEDRIVE_API_DLL_PUBLIC DownloadBufferCb
+{
+    std::string content_id;
+    Task::Buffer_Callback write_cb;
+};
+
+class DownloadTaskPriv;
+class SyncManagerPriv;
+
+/*!
+    \class DownloadTask
+    \brief DownloadTask is a task item that can be accessed from application layer to fetch
+    basic download item information, also it's used for content download by sync manager.
+ */
+class ONEDRIVE_API_DLL_PUBLIC DownloadTask : public Task {
+public:
+    typedef std::shared_ptr<DownloadTask> Ptr;
+
+    virtual ~DownloadTask() = default;
+
+    DownloadTask& operator=(const DownloadTask& ) = delete;
+
+    /*!
+     * \brief Returns a display name of cloud content on onedrive.
+     */
+    const std::string & content_name() const override;
+
+    /*!
+     * \brief Returns cloud content local storage file path.
+     */
+    const std::string & file_path() const override;
+
+    /*!
+     * \brief Returns download url assigned by onedrive for this task.
+     * \note this url will be expried after a period of time.
+     */
+    const std::string & task_url() const override;
+
+    /*!
+     * \brief Contains the error code if an error occurs during content download.
+     */
+    const std::string & error_code() const override;
+
+    /*!
+     * \brief Contains the error string if an error occurs during content download.
+     */
+    const std::string & error_message() const override;
+
+    /*!
+     * \brief Returns current sync-up status for this task.
+     * \sa Task::TaskStatus
+     */
+    Task::Status status() const override;
+
+    /*!
+     * \brief Handler for download progress of a task.
+     * \sa Task::ProgressHandler
+     */
+    Task::ProgressHandler & progress_changed() override;
+
+    /*!
+     * \brief Handler for download status of a task.
+     * \sa Task::StatusHandler
+     */
+    Task::StatusHandler & status_changed() override;
+
+    /*! 
+     * \brief cancel the task.
+     * \sa Task::StatusHandler
+     */
+    void cancel() override;
+
+private:
+    DownloadTask(std::shared_ptr<DownloadTaskPriv> p);
+
+    friend class SyncManagerPriv;
+
+    std::shared_ptr<DownloadTaskPriv>   p_;
+};
+
+}
+}
+
+#endif // ONEDRIVE_API_DOWNLOADTASK_H_

=== added file 'include/onedrive/api/exceptions.h'
--- include/onedrive/api/exceptions.h	1970-01-01 00:00:00 +0000
+++ include/onedrive/api/exceptions.h	2016-09-30 08:26:58 +0000
@@ -0,0 +1,87 @@
+/*
+ * Copyright © 2016 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Gary Wang <[e-mail]>
+ */
+
+#ifndef ONEDRIVE_API_EXCEPTIONS_H_
+#define ONEDRIVE_API_EXCEPTIONS_H_
+
+#include <onedrive/api/visibility.h>
+
+#include <exception>
+
+namespace onedrive {
+namespace api {
+
+    /**
+     * \brief Indicates a content or folder can not be found on onedrive.
+     */
+    class ONEDRIVE_API_DLL_PUBLIC NonExistentException : public std::runtime_error {
+		public:
+			using runtime_error::runtime_error;
+	};
+
+    /**
+     * \brief User ran out of space on onedrive storage.
+     */
+    class ONEDRIVE_API_DLL_PUBLIC OutofSpaceException : public std::runtime_error {
+        public:
+            using runtime_error::runtime_error;
+    };
+   
+    /**
+     * \brief Indicates a timeout on HTTP requests.
+     */
+    class  ONEDRIVE_API_DLL_PUBLIC HttpTimeoutException : public std::runtime_error {
+        public:
+            using runtime_error::runtime_error;
+    };
+
+    /**
+     * \brief Indicates one or more http request parameters are invalid.
+     */
+    class ONEDRIVE_API_DLL_PUBLIC ParameterInvalidException : public std::runtime_error {
+        public:
+            using runtime_error::runtime_error;
+    };
+
+    /**
+     * \brief Indicates access token is invalid or expired.
+     */
+    class ONEDRIVE_API_DLL_PUBLIC CredentialException : public std::runtime_error {
+        public:
+            using runtime_error::runtime_error;
+    };
+
+    /**
+     * \brief Indicates The service is not available. Try the request again after a delay.
+     */
+    class ONEDRIVE_API_DLL_PUBLIC ServiceNotAvailableException : public std::runtime_error {
+        public:
+            using runtime_error::runtime_error;
+    };
+
+    /**
+     * \brief Unknown exception.
+     */
+    class ONEDRIVE_API_DLL_PUBLIC UnknownException : public std::runtime_error {
+        public:
+            using runtime_error::runtime_error;
+    };
+}
+}
+
+#endif // ONEDRIVE_API_EXCEPTIONS_H_

=== added file 'include/onedrive/api/storageinfo.h'
--- include/onedrive/api/storageinfo.h	1970-01-01 00:00:00 +0000
+++ include/onedrive/api/storageinfo.h	2016-09-30 08:26:58 +0000
@@ -0,0 +1,74 @@
+/*
+ * Copyright © 2016 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Gary Wang <[e-mail]>
+ */
+
+#ifndef ONEDRIVE_API_STORAGEINFO_H_
+#define ONEDRIVE_API_STORAGEINFO_H_
+
+#include <onedrive/api/visibility.h>
+
+#include <memory>
+#include <string>
+
+namespace Json {
+    class Value;
+}
+
+namespace onedrive {
+namespace api {
+
+/*!
+    \class StorageInfo
+    \brief StorageInfo is a class that provides basic user's account and storage usage information on onedrive.
+ */
+
+class ONEDRIVE_API_DLL_PUBLIC StorageInfo {
+public:
+    virtual ~StorageInfo() = default;
+
+    /*!
+     * \brief Returns authorized user's id.
+     */
+    const std::string &id() const;
+
+    /*!
+     * \brief Returns authorized user's name.
+     */
+    const std::string &name() const;
+
+    /*!
+     * \brief Returns used disk size of user cloud storage in Bytes.
+     */
+    int64_t used_disk_size() const;
+
+    /*!
+     * \brief Returns total disk size assigned by onedrive in Bytes.
+     */
+    int64_t total_disk_size() const;
+private:
+    StorageInfo(const Json::Value &root);
+
+    friend class ClientPriv;
+    class Priv;
+
+    std::shared_ptr<Priv>   p;
+};
+
+}
+}
+
+#endif // ONEDRIVE_API_STORAGEINFO_H_

=== added file 'include/onedrive/api/syncmanager.h'
--- include/onedrive/api/syncmanager.h	1970-01-01 00:00:00 +0000
+++ include/onedrive/api/syncmanager.h	2016-09-30 08:26:58 +0000
@@ -0,0 +1,171 @@
+/*
+ * Copyright © 2016 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Gary Wang <[e-mail]>
+ */
+
+#ifndef ONEDRIVE_API_SYNCMANAGER_H_
+#define ONEDRIVE_API_SYNCMANAGER_H_
+
+#include <onedrive/api/taskqueue.h>
+#include <onedrive/api/downloadtask.h>
+#include <onedrive/api/uploadtask.h>
+#include <onedrive/api/visibility.h>
+
+#include <memory>
+#include <vector>
+
+namespace onedrive {
+namespace api {
+
+class ClientPriv;
+class SyncManagerPriv;
+
+/*!
+    \class SyncManager
+    \brief SyncManager handles all the requests to upload and download.
+    It's constructed around two threads for content synchronization. One for content upload to cloud, another for cloud item download to local.
+    Both thread are running asynchronously.
+    Calls \sa add_download_task() by passing a content id list for cloud content download,
+    Calls \sa add_upload_tasks() by passing a local file path for local content upload.
+ */
+
+class ONEDRIVE_API_DLL_PUBLIC SyncManager {
+  public:
+    typedef std::shared_ptr<SyncManager> Ptr;
+
+    typedef TaskQueue<DownloadTask::Ptr> DownloadList;
+
+    typedef TaskQueue<UploadTask::Ptr>  UploadList;
+
+    typedef std::vector<std::string>    Stringlist;
+
+    virtual ~SyncManager() = default;
+
+    SyncManager(const SyncManager&) = delete;
+
+    SyncManager& operator=(const SyncManager &) = delete;
+
+    /*!
+     * \brief Starts to run download or upload tasks from sync-up thread.
+     * The tasks can be resumed by sync-up thread if sync manager is paused or canceled before.
+     * \sa pause(), cancel()
+     */
+    void start();
+
+    /*!
+     * \brief Cancels all download or upload tasks from sync-up thread if sync manager is running.
+     * \note A canceled download or upload task has no chance to run again by sync-up thread.
+     * \sa start(), pause()
+     */
+    void cancel();
+
+    /*!
+     * \brief Pauses download or upload task from sync-up thread if sync manager is running.
+     * Sync-up thread can continue to run previous paused task by calling \sa start()
+     * \sa start(), cancel()
+     */
+    void pause();
+
+    /*!
+     * \brief Pushes a content id \a contentid_list into download queue.
+     * \return download task item that is pushed in sync-up manager.
+     * \throw std::runtime_error if error occurs.
+     * \sa add_download_tasks(), DownloadTask
+     */
+    DownloadTask::Ptr add_download_task(const std::string &content_id);
+
+    /*!
+     * \brief Pushes a download buffer callback item \a buffer_cb_item into download queue.
+     * Each download buffer consists of the following fields
+     *      - `write_cb` (std::function<size_t(void *dest, size_t buf_size)>)
+     *         buffer reading callback function.
+     *         The buffer area pointed at by the pointer \a dest should be filled up with at most \a buf_size number of bytes.
+     *      - `content_id` (string)
+     *         The id of content on onedrive.
+     * \return download task item that is pushed in sync-up manager.
+     * \throw std::runtime_error if error occurs.
+     * \sa add_download_tasks(), DownloadTask
+     */
+    DownloadTask::Ptr add_download_task(const DownloadBufferCb &buffer_cb_item);
+
+    /*!
+     * \brief Pushes a upload request item \a reqeust_item to sync manager and add regarding upload task into upload queue.
+     * A upload request consists of the following fields
+     *      - `file_path` (string)
+     *         local file path.
+     *      - `folder_id` (string)
+     *         onedrive folder id which stores content in uploads folder.
+     *      - `content_name` (string)
+     *         uploaded content name.
+     * If content_name is empty, local file name will be used as a content name displayed on onedrive.
+     * If folder_id is empty, content will be uploaded into root folder.
+     * \return upload task item that is pushed in sync-up manager.
+     * \throw std::runtime_error if error occurs.
+     * \note A file name can not contain any of following characters:
+     *      '\', '/', ':', '*', '?', '"', '<', '>', '|'
+     * \note Sync manager will detect if the uploading file is already existing on cloud,
+     * if so, it simply sets the status of upload task completed to avoid duplicate upload.
+     * \sa add_download_tasks(), UploadRequest, UploadTask,
+     */
+    UploadTask::Ptr add_upload_task(const UploadRequest &reqeust_item);
+
+    /*!
+     * \brief Pushes a upload callback item \a buffer_cb to sync manager and add regarding upload task into upload queue.
+     * A upload buffer consists of the following fields
+     *      - `read_cb` (std::function<size_t(void *dest, size_t buf_size)>)
+     *         buffer reading callback function.
+     *         The buffer area pointed at by the pointer \a dest should be filled up with at most \a buf_size number of bytes.
+     *      - `buffer_size` (size_t)
+     *         total size of data buffers.
+     *      - `folder_id` (string)
+     *         onedrive folder id which stores content in uploads folder.
+     *      - `content_name` (string)
+     *         uploaded content name, should not be empty.
+     * If folder_id is empty, content will be uploaded into root folder.
+     * \return upload task item that are pushed in sync-up manager.
+     * \throw std::runtime_error if error occurs.
+     * \note A file name can not contain any of following characters:
+     *      '\', '/', ':', '*', '?', '"', '<', '>', '|'
+     * \sa add_download_tasks(), UploadRequest, UploadTask,
+     */
+    UploadTask::Ptr add_upload_task(const UploadBufferCb &buffer_cb);
+
+    /*!
+     * \brief Returns a download task list hold by sync up manager.
+     * Each item in the list contains basic information of associated task.
+     * \sa upload_queue(), DownloadTask
+     */
+    DownloadList download_queue();
+
+    /*!
+     * \brief Returns a upload task list hold by sync up manager.
+     * Each item in the list contains basic information of associated task.
+     * \sa download_queue(), UploadTask
+     */
+    UploadList   upload_queue();
+
+private:
+    SyncManager(ClientPriv* client_priv);
+
+    friend class ClientPriv;
+
+    std::shared_ptr<SyncManagerPriv> p_;
+};
+
+}
+}
+
+#endif // ONEDRIVE_API_SYNCMANAGER_H_

=== added file 'include/onedrive/api/task.h'
--- include/onedrive/api/task.h	1970-01-01 00:00:00 +0000
+++ include/onedrive/api/task.h	2016-09-30 08:26:58 +0000
@@ -0,0 +1,119 @@
+/*
+ * Copyright © 2016 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Gary Wang <[e-mail]>
+ */
+
+#ifndef ONEDRIVE_API_TASK_H_
+#define ONEDRIVE_API_TASK_H_
+
+#include <onedrive/api/visibility.h>
+#include <functional>
+#include <string>
+
+namespace onedrive {
+namespace api {
+
+/*!
+    \class Task
+    \brief Task is an abstract class that defines common interfaces for upload and download task.
+ */
+
+class ONEDRIVE_API_DLL_PUBLIC Task {
+public:
+    /*!
+     * \brief The Status enum indicates current status of this task.
+     */
+    enum class Status {
+        Unstart,        ///< Task is in queue and sync manager does not run this task yet.
+        Running,        ///< Task is being processed by sync manager.
+        Canceled,       ///< Task is in canceled status, it is caused by the call from Client::cancel_sync().
+        Paused,         ///< Task is in paused status, it is caused by the call from Client::pause_sync().
+        Broken,         ///< Task is broken when sync manager failed to download/upload a task after several times trying.
+        Complete,       ///< Task is completed.
+    };
+
+    /*!
+     * \brief The name conflict enum which can be specified the behavior to use if the file already exists.
+     * The default for PUT is replace.
+     */
+    enum class NameConflictBehavior {
+        Fail,           ///<Failed if the file already exists.
+        Replace,        ///<Replace current content if the file already exists.
+        Rename          ///<Automatically renamed by onedrive if the file already exists.
+    };
+
+    typedef std::function<void(float)> ProgressHandler;
+
+    typedef std::function<void(Status)> StatusHandler;
+
+    typedef std::function<size_t(void *dest, size_t buf_size)> Buffer_Callback;
+
+    virtual ~Task() = default;
+
+    /*!
+     * \brief Returns a display name of cloud content on onedrive.
+     */
+    virtual const std::string & content_name() const = 0;
+
+    /*!
+     * \brief Returns cloud content local storage file path.
+     */
+    virtual const std::string & file_path() const = 0;
+
+    /*!
+     * \brief Contains the error code if an error occurs during task running.
+     */
+    virtual const std::string & error_code() const = 0;
+
+    /*!
+     * \brief Contains the error string if an error occurs during task running.
+     */
+    virtual const std::string & error_message() const = 0;
+
+    /*!
+     * \brief Returns a item task url.
+     * \note the url will be expried after a period of time.
+     */
+    virtual const std::string & task_url() const = 0;
+
+    /*!
+     * \brief Returns current download or upload item sync-up status.
+     */
+    virtual Task::Status status() const = 0;
+
+    /*!
+     * \brief Handler for download or upload progress of a task.
+     * \sa Task::ProgressHandler
+     */
+    virtual Task::ProgressHandler & progress_changed() = 0;
+
+    /*!
+     * \brief Handler for download or upload progress of a task.
+     * \sa Task::StatusHandler
+     */
+    virtual Task::StatusHandler & status_changed() = 0;
+
+    /*!
+     * \brief Cancel the task.
+     * \sa Task::StatusHandler
+     */
+    virtual void cancel() = 0;
+};
+
+}
+}
+
+#endif // ONEDRIVE_API_TASK_H_

=== added file 'include/onedrive/api/taskqueue.h'
--- include/onedrive/api/taskqueue.h	1970-01-01 00:00:00 +0000
+++ include/onedrive/api/taskqueue.h	2016-09-30 08:26:58 +0000
@@ -0,0 +1,131 @@
+/*
+ * Copyright © 2016 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Gary Wang <[e-mail]>
+ */
+
+#ifndef ONEDRIVE_API_TASKQUEUE_H_
+#define ONEDRIVE_API_TASKQUEUE_H_
+
+#include <memory>
+#include <deque>
+#include <mutex>
+
+namespace onedrive {
+namespace api {
+
+/*!
+    \class TaskQueue
+    \brief A thread-safe deque template.
+ */
+template<typename T, typename Container = std::deque<T>>
+class TaskQueue {
+  public:
+    typedef std::shared_ptr<TaskQueue> Ptr;
+    typedef typename Container::size_type size_type;
+    typedef typename Container::const_iterator const_iterator;
+
+    TaskQueue() = default;
+
+    virtual ~TaskQueue() = default;
+
+    TaskQueue(TaskQueue &&queue) {
+        std::lock_guard<std::mutex> lock(mutex_);
+        tasks_ = std::move(queue.tasks_);
+    }
+
+    TaskQueue(const TaskQueue &queue) {
+        std::lock_guard<std::mutex> lock(mutex_);
+        tasks_ = queue.tasks_;
+    }
+
+    TaskQueue &operator= (const TaskQueue &queue) {
+        if (this != &queue) {
+            std::lock_guard<std::mutex> lock1(mutex_);
+            std::lock_guard<std::mutex> lock2(queue.mutex_);
+            tasks_ = queue.tasks_;
+        }
+
+        return *this;
+    }
+
+    typename Container::iterator begin() {
+        std::lock_guard<std::mutex> lock(mutex_);
+        return tasks_.begin();
+    }
+
+    typename Container::iterator end() {
+        std::lock_guard<std::mutex> lock(mutex_);
+        return tasks_.end();
+    }
+
+    typename Container::iterator cbegin() const {
+        std::lock_guard<std::mutex> lock(mutex_);
+        return tasks_.cbegin();
+    }
+
+    typename Container::iterator cend() const {
+        std::lock_guard<std::mutex> lock(mutex_);
+        return tasks_.cend();
+    }
+
+    size_type size() const {
+        std::lock_guard<std::mutex> lock(mutex_);
+        return tasks_.size();
+    }
+
+    bool empty() const {
+        std::lock_guard<std::mutex> lock(mutex_);
+        return tasks_.empty();
+    }
+
+    void push(const T &task) {
+        std::lock_guard<std::mutex> lock(mutex_);
+        tasks_.push_back(task);
+    }
+
+    void push(const TaskQueue & queue) {
+        std::lock_guard<std::mutex> lock(mutex_);
+        for (const T & task: queue.tasks_){
+            tasks_.push_back(task);
+        }
+    }
+
+    bool try_pop(T &task) {
+        std::lock_guard<std::mutex> lock(mutex_);
+
+        if (tasks_.empty())
+          return false;
+
+        task = tasks_.front();
+        tasks_.pop_front();
+        return true;
+    }
+
+    const T & operator[](int index) const {
+        std::lock_guard<std::mutex> lock(mutex_);
+        return tasks_[index];
+    }
+
+  private:
+    Container  tasks_;
+
+    mutable std::mutex mutex_;
+};
+
+}
+}
+
+#endif // ONEDRIVE_API_TASKQUEUE_H_

=== added file 'include/onedrive/api/uploadtask.h'
--- include/onedrive/api/uploadtask.h	1970-01-01 00:00:00 +0000
+++ include/onedrive/api/uploadtask.h	2016-09-30 08:26:58 +0000
@@ -0,0 +1,176 @@
+/*
+ * Copyright © 2016 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Gary Wang <[e-mail]>
+ */
+
+#ifndef ONEDRIVE_API_UPLOADTASK_H_
+#define ONEDRIVE_API_UPLOADTASK_H_
+
+#include <onedrive/api/task.h>
+#include <onedrive/api/visibility.h>
+
+#include <memory>
+#include <vector>
+
+namespace Json {
+    class Value;
+}
+
+namespace onedrive {
+namespace api {
+
+class TaskHandler;
+
+/*!
+    \struct UploadRequest
+    \brief UploadRequest is a upload request item which consists of a upload folder id, up-front buffer size,
+    upload content name
+ */
+struct ONEDRIVE_API_DLL_PUBLIC UploadRequest
+{
+    UploadRequest(std::string local_file_path,
+                  std::string parent_folder_id,
+                  std::string upload_file_name,
+                  Task::NameConflictBehavior conflict_name_behavior = Task::NameConflictBehavior::Replace)
+        :file_path(local_file_path),
+         folder_id(parent_folder_id),
+         content_name(upload_file_name),
+         conflict_behavior(conflict_name_behavior){
+    }
+
+    std::string file_path;
+    std::string folder_id;
+    std::string content_name;
+    Task::NameConflictBehavior conflict_behavior;
+};
+typedef std::vector<UploadRequest> UploadRequestList;
+
+/*!
+    \struct UploadBufferCb
+    \brief UploadBufferCb is a upload request item which consists of a upload folder id, upload buffer size,
+    upload content name and reading callback function allows content data can be received in buffering via call
+    back function.
+*/
+struct ONEDRIVE_API_DLL_PUBLIC UploadBufferCb
+{
+    UploadBufferCb(Task::Buffer_Callback read_callback,
+                   size_t      upload_buf_size,
+                   std::string parent_folder_id,
+                   std::string upload_file_name,
+                   Task::NameConflictBehavior conflict_name_behavior = Task::NameConflictBehavior::Replace)
+        :read_cb(read_callback),
+         buffer_size(upload_buf_size),
+         folder_id(parent_folder_id),
+         content_name(upload_file_name),
+         conflict_behavior(conflict_name_behavior){
+    }
+
+    Task::Buffer_Callback read_cb;
+    size_t      buffer_size;
+    std::string folder_id;
+    std::string content_name;
+    Task::NameConflictBehavior conflict_behavior = Task::NameConflictBehavior::Replace;
+};
+typedef std::vector<UploadBufferCb> UploadBufferCbList;
+
+class UploadTaskPriv;
+class CloudItem;
+
+/*!
+    \class UploadTask
+    \brief UploadTask is a task item that can be accessed from application layer to fetch
+    basic upload item information, also it's used for content upload by sync manager.
+ */
+class ONEDRIVE_API_DLL_PUBLIC UploadTask : public Task {
+public:
+    typedef std::shared_ptr<UploadTask> Ptr;
+
+    virtual ~UploadTask() = default;
+
+    UploadTask& operator=(const UploadTask& ) = delete;
+
+    /*!
+     * \brief Returns a display name of local content.
+     */
+    const std::string & content_name() const override;
+
+    /*!
+     * \brief Returns uploaded local content file path.
+     */
+    const std::string & file_path() const override;
+
+    /*!
+     * \brief Returns download url assigned by onedrive for this task.
+     * \note this url will be expried after a period of time.
+     */
+    const std::string & task_url() const override;
+
+    /*!
+     * \brief Contains the error code if an error occurs during content uploading.
+     */
+    const std::string & error_code() const override;
+
+    /*!
+     * \brief Contains the error string if an error occurs during content uploading.
+     */
+    const std::string & error_message() const override;
+
+    /*!
+     * \brief Returns current sync-up status for this task.
+     */
+    Task::Status status() const override;
+
+    /*!
+     * \brief Handler for upload progress of a task.
+     * \sa Task::ProgressHandler
+     */
+    Task::ProgressHandler & progress_changed() override;
+
+    /*!
+     * \brief Handler for upload status of a task.
+     * \sa Task::StatusHandler
+     */
+    Task::StatusHandler & status_changed() override;
+
+    /*!
+     * \brief Returns a cloud item object associated with the uploaded content.
+     * \note Returns nullptr if task failed to upload regarding content on onedrive.
+     */
+    std::shared_ptr<CloudItem>  upload_item() const;
+
+    /*!
+     * \brief cancel the task.
+     * \sa Task::StatusHandler
+     */
+    void cancel() override;
+
+    /*!
+     * \brief Returns file size of upload content.
+     */
+    size_t file_size() const;
+
+private:
+    UploadTask(std::shared_ptr<UploadTaskPriv> p);
+
+    friend class SyncManagerPriv;
+
+    std::shared_ptr<UploadTaskPriv>   p_;
+};
+
+}
+}
+
+#endif // ONEDRIVE_API_UPLOADTASK_H_

=== added file 'include/onedrive/api/visibility.h'
--- include/onedrive/api/visibility.h	1970-01-01 00:00:00 +0000
+++ include/onedrive/api/visibility.h	2016-09-30 08:26:58 +0000
@@ -0,0 +1,30 @@
+/*
+ * Copyright (C) 2016 Canonical, Ltd.
+ *
+ * This library is free software; you can redistribute it and/or modify it under
+ * the terms of version 3 of the GNU Lesser General Public License as published
+ * by the Free Software Foundation.
+ *
+ * This library is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
+ * details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Author: Gary Wang  <[e-mail]>
+ */
+
+#ifndef ONEDRIVE_API_VISIBILITY_H_
+#define ONEDRIVE_API_VISIBILITY_H_
+
+#if __GNUC__ >= 4
+#define ONEDRIVE_API_DLL_PUBLIC __attribute__ ((visibility ("default")))
+#define ONEDRIVE_API_DLL_LOCAL  __attribute__ ((visibility ("hidden")))
+#else
+#define ONEDRIVE_API_DLL_PUBLIC
+#define ONEDRIVE_API_DLL_LOCAL
+#endif
+
+#endif // ONEDRIVE_API_VISIBILITY_H_

=== modified file 'provider/CMakeLists.txt'
--- provider/CMakeLists.txt	2016-09-26 04:27:03 +0000
+++ provider/CMakeLists.txt	2016-09-30 08:26:58 +0000
@@ -0,0 +1,32 @@
+find_package(PkgConfig REQUIRED)
+find_package(Boost COMPONENTS filesystem system thread REQUIRED)
+
+pkg_check_modules(STORAGE_FRAMEWORK_PROVIDER storage-framework-provider-1 REQUIRED)
+
+include_directories(${CMAKE_CURRENT_BINARY_DIR} ${STORAGE_FRAMEWORK_PROVIDER_INCLUDE_DIRS})
+                    
+add_definitions(-DBOOST_THREAD_VERSION=4)
+
+add_executable(onedrive-provider-bin OnedriveProvider.cpp)
+
+target_link_libraries(
+    onedrive-provider-bin
+    onedrive-provider
+    
+    ${Boost_LIBRARIES}
+    ${STORAGE_FRAMEWORK_PROVIDER_LDFLAGS} 
+)
+
+SET_TARGET_PROPERTIES(onedrive-provider-bin
+    PROPERTIES OUTPUT_NAME onedrive-provider
+)
+
+install(
+    TARGETS onedrive-provider-bin
+    RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
+)
+
+install(
+    FILES ${CMAKE_CURRENT_SOURCE_DIR}/com.canonical.StorageFramework.Provider.OnedriveProvider.service
+    DESTINATION /usr/share/dbus-1/services
+)

=== added file 'provider/OnedriveProvider.cpp'
--- provider/OnedriveProvider.cpp	1970-01-01 00:00:00 +0000
+++ provider/OnedriveProvider.cpp	2016-09-30 08:26:58 +0000
@@ -0,0 +1,634 @@
+/*
+ * Copyright (C) 2016 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authors: Gary Wang <[e-mail]>
+ */
+
+#include "OnedriveProvider.h"
+#include <unity/storage/provider/ProviderBase.h>
+#include <unity/storage/provider/Server.h>
+#include <unity/storage/provider/TempfileUploadJob.h>
+#include <unity/storage/provider/UploadJob.h>
+#include <unity/storage/provider/DownloadJob.h>
+#include <unity/storage/provider/metadata_keys.h>
+#include <unity/storage/provider/Exceptions.h>
+
+#include <boost/thread.hpp>
+#include <boost/thread/future.hpp>
+#include <boost/filesystem.hpp>
+#include <boost/make_shared.hpp>
+
+#include <unistd.h>
+#include <sys/socket.h>
+#include <inttypes.h>
+#include <unistd.h>
+#include <iostream>
+#include <memory>
+#include <mutex>
+#include <stdexcept>
+#include <condition_variable>
+  
+#include <onedrive/api/client.h>
+#include <onedrive/api/uploadtask.h>
+#include <onedrive/api/syncmanager.h>
+#include <onedrive/api/cloudresource.h>
+#include <onedrive/api/cloudcontent.h>
+#include <onedrive/api/cloudfolder.h>
+#include <onedrive/api/exceptions.h>
+
+using namespace std;
+using namespace unity::storage;
+using namespace unity::storage::provider;
+using namespace onedrive::api;
+
+using boost::make_ready_future;
+using boost::make_exceptional_future;
+
+namespace {
+    static const int   TIME_OUT = 10;
+
+    static const char *FOLDER_TYPE[]  = {"normal", "pictures", "music", "videos", "message", "docs", "app", "sync"};  
+    static const char *CONTENT_TYPE[] = {"all", "image", "audio", "video", "other", "doc", "spreadsheet", "ppt"};
+    static const char *STATUS[]       = {"unstart", "running", "canceled", "paused", "broken", "complete"};
+    static char constexpr SIZE_IN_BYTES[] = "size_in_bytes";
+
+    string make_job_id()
+    {
+        static int last_upload_id = 0;
+        return to_string(++last_upload_id);
+    }
+
+    string status_to_string(Task::Status status)
+    {
+        return STATUS[int(status)];
+    }
+
+    string folder_type_to_string(CloudFolder::Type type)
+    {
+        return FOLDER_TYPE[int(type)];
+    }
+
+    string content_type_to_string(CloudContent::Type type)
+    {
+        return CONTENT_TYPE[int(type)];
+    }
+
+    string time_to_iso(time_t t)
+    {
+        char buf[sizeof "2016-08-11T15:10:07"];
+        strftime(buf, sizeof buf, "%FT%T", gmtime(&t));
+        return buf; 
+    }
+
+    Item content_to_item(CloudResource::Ptr resource)
+    {
+        Item item;
+        item.item_id = resource->id();
+        item.parent_ids = {resource->folder_id()};
+        item.name = resource->name();
+        item.etag = resource->etag();
+        item.metadata["owner"] = resource->owner();
+        item.metadata[provider::CREATION_TIME] = time_to_iso(resource->created_date());
+        item.metadata[provider::LAST_MODIFIED_TIME] = time_to_iso(resource->updated_date());
+        if (resource->property() == CloudResource::Property::Folder) {
+            item.type = ItemType::folder;
+            auto folder = std::static_pointer_cast<onedrive::api::CloudFolder>(resource);
+            item.metadata["folder_type"] = folder_type_to_string(folder->folder_type());
+            item.metadata["folder_path"] = folder->folder_path();
+        } else if (resource->property() == CloudResource::Property::Content){
+            item.type = ItemType::file;
+            auto file = std::static_pointer_cast<onedrive::api::CloudContent>(resource);
+            item.metadata["suffix"] = file->suffix();
+            item.metadata["content_type"] = content_type_to_string(file->type());
+
+            item.metadata[provider::SIZE_IN_BYTES] = file->content_size();
+            item.metadata["description"] = file->description();
+            item.metadata["thumbnail_url"] = file->thumbnail_url();
+            item.metadata["big_thumbnail_url"] = file->big_thumbnail_url();
+            item.metadata["present_url"] = file->big_thumbnail_url();
+        }
+
+        return item;
+    }
+}
+
+class OnedriveUploadJob : public UploadJob
+{
+public:
+    OnedriveUploadJob(string const& upload_id,
+                      Client::Ptr client,
+                      string const& parent_id,
+                      string const& file_name,
+                      int64_t       size,
+                      bool allow_overwrite);
+
+    boost::future<void> cancel() override;
+    boost::future<Item> finish() override;
+private:
+    boost::future<tuple<bool, string>> upload_data(); 
+    void   stop_and_cancel();
+private:
+    ssize_t     feed_size;
+    string  parent_id_;
+    string  file_name_;
+    int64_t  upload_size_;
+    bool    allow_overwrite_;
+
+    boost::future<tuple<bool, string>> upload_future_;
+
+    std::mutex    mutex_;
+
+    UploadTask::Ptr task_; 
+    Client::Ptr     client_;
+};
+
+class OnedriveDownloadJob : public DownloadJob
+{
+public:
+    using DownloadJob::DownloadJob;
+
+    OnedriveDownloadJob(string const& download_id,
+                        string const& item_id,
+                        Client::Ptr client);
+
+    boost::future<void> cancel() override;
+    boost::future<void> finish() override;
+private:
+    boost::future<tuple<bool, string>> download_data();
+    void send_data();
+    void stop_and_cancel();
+private:
+    string  item_id_;
+    boost::future<tuple<bool, string>>  download_future_;
+
+    std::mutex           mutex_;
+	
+    DownloadTask::Ptr    task_;
+    Client::Ptr          client_;
+};
+
+OnedriveProvider::OnedriveProvider() 
+    : client_(std::make_shared<Client>(TIME_OUT))
+{
+}
+
+boost::future<ItemList> OnedriveProvider::roots(Context const& ctx)
+{
+    set_access_token(ctx);
+   
+    return boost::async([this](){
+        try {
+            auto root_folder_id = client_->cloud_root_folder_id();
+
+            ItemList roots = {
+                {root_folder_id, {}, "root", "", ItemType::root, {}}
+            };
+
+            return make_ready_future<ItemList>(roots);
+        } catch (runtime_error &e) {
+            return make_exceptional_future<ItemList>(
+                    RemoteCommsException(string("OnedriveProvider::roots(): failed: ") + e.what())); 
+        }
+    });
+}
+
+boost::future<tuple<ItemList,string>> OnedriveProvider::list(
+    string const& item_id, string const& page_token,
+    Context const& ctx)
+{
+    set_access_token(ctx);
+
+    int page_token_index = 0;
+    if (!page_token.empty()) {
+        try {
+            page_token_index = stoi(page_token);
+        } catch (invalid_argument &e) {
+            return make_exceptional_future<tuple<ItemList,string>>(
+                    InvalidArgumentException(string("OnedriveProvider::list(): invalid page token: ") + e.what()));
+        }
+    }
+
+    return boost::async([this, item_id, page_token_index](){
+        try {
+            const int count_per_page = 50;
+            int start_index = 1 + page_token_index * count_per_page;
+            auto content_list = client_->cloud_content_list(start_index, count_per_page,
+                                                            CloudContent::Type::All, item_id);
+
+            ItemList roots;
+            for (const auto & content: content_list) {
+                roots.push_back(content_to_item(content));
+            }
+
+            int offset = 0;
+            boost::promise<tuple<ItemList,string>> prom;
+            if (content_list.size() >= count_per_page) {
+                offset++;
+            }
+            prom.set_value(make_tuple(roots, std::to_string(page_token_index + offset)));
+            
+            return prom.get_future();
+        } catch (InvalidIDException &e) {
+            return make_exceptional_future<tuple<ItemList,string>>(
+                    NotExistsException(string("OnedriveProvider::list(): failed: ") + e.what(), item_id)); 
+        } catch (runtime_error &e) {
+            return make_exceptional_future<tuple<ItemList,string>>(
+                    RemoteCommsException(string("OnedriveProvider::list(): failed: ") + e.what())); 
+        }
+    });
+}
+
+boost::future<ItemList> OnedriveProvider::lookup(
+    string const& parent_id, string const& name,
+    Context const& ctx)
+{
+    set_access_token(ctx);
+
+    return boost::async([this, parent_id, name](){
+        try {
+            const int count_per_page = 50;
+            int page_token_index = 0;
+            int start_index = 0;
+
+            ItemList roots;
+            do {
+                page_token_index++;
+                start_index = 1 + (page_token_index - 1) * count_per_page;
+                auto content_list = client_->cloud_content_list(start_index, count_per_page,
+                                                           CloudContent::Type::All, parent_id);
+
+                for (const auto & content: content_list) {
+                    if (content->name().find(name) != string::npos) {
+                        roots.push_back(content_to_item(content));
+                    }
+                }
+
+                if (content_list.size() < count_per_page)
+                    break;
+            } while (true);
+
+            return make_ready_future<ItemList>(roots);
+        } catch (InvalidIDException &e) {
+            return make_exceptional_future<ItemList>(
+                    NotExistsException(string("OnedriveProvider::lookup(): folder not exists: ") + e.what(), parent_id)); 
+        } catch (runtime_error &e) {
+            return make_exceptional_future<ItemList>(
+                    RemoteCommsException(string("OnedriveProvider::lookup(): failed: ") + e.what())); 
+        }
+    });
+}
+
+boost::future<Item> OnedriveProvider::metadata(string const& item_id,
+                                             Context const& ctx)
+{
+    set_access_token(ctx);
+
+    return boost::async([this, item_id](){
+        try {
+            auto content = client_->metadata(item_id);
+            return make_ready_future<Item>(content_to_item(content));
+        } catch (NonExistentException &e) {
+            return make_exceptional_future<Item>(
+                    NotExistsException(string("OnedriveProvider::metadata(): content not exists: ") + e.what(), item_id)); 
+        } catch (runtime_error &e) {
+            return make_exceptional_future<Item>(
+                    RemoteCommsException(string("OnedriveProvider::metadata(): failed: ") + e.what())); 
+        }
+    });
+}
+
+boost::future<Item> OnedriveProvider::create_folder(
+        string const& parent_id, string const& name,
+        Context const& ctx)
+{
+    set_access_token(ctx);
+
+    return boost::async([this, parent_id, name](){
+        try {
+            auto content = client_->create_folder(name, parent_id);
+            return make_ready_future<Item>(content_to_item(content));
+        } catch (NonExistentException &e) {
+            return make_exceptional_future<Item>(
+                    NotExistsException(string("OnedriveProvider::create_folder(): name: ") + e.what(), name)); 
+        } catch (runtime_error &e) {
+            return make_exceptional_future<Item>(
+                    RemoteCommsException(string("OnedriveProvider::create_folder(): failed: ") + e.what())); 
+        }
+    });
+}
+
+boost::future<unique_ptr<UploadJob>> OnedriveProvider::create_file(
+    string const& parent_id, string const& name,
+    int64_t size, string const& /*content_type*/, bool allow_overwrite,
+    Context const& ctx)
+{
+    set_access_token(ctx);
+
+    return make_ready_future(unique_ptr<UploadJob>(new OnedriveUploadJob(make_job_id(), client_, parent_id, name, size, allow_overwrite)));
+}
+
+boost::future<unique_ptr<UploadJob>> OnedriveProvider::update(
+    string const& item_id, int64_t size, string const& /*old_etag*/, 
+    Context const& ctx)
+{
+    set_access_token(ctx);
+
+    return boost::async([this, item_id, size, ctx](){
+        try {
+            auto content = client_->metadata(item_id);
+            auto file_name = content->name();
+            auto parent_id = content->folder_id();
+
+            delete_item(item_id, ctx);
+
+            return create_file(parent_id, file_name, size, "", true, ctx);
+        } catch (runtime_error &e) {
+            return make_exceptional_future<unique_ptr<UploadJob>>(
+                    RemoteCommsException(string("OnedriveProvider::update(): failed: ") + e.what()));
+        }
+    });
+}
+
+boost::future<unique_ptr<DownloadJob>> OnedriveProvider::download(
+    string const& item_id, Context const& ctx)
+{
+    set_access_token(ctx);
+
+    return make_ready_future(unique_ptr<DownloadJob>(new OnedriveDownloadJob(make_job_id(), item_id, client_)));
+}
+
+boost::future<void> OnedriveProvider::delete_item(
+    string const& item_id, Context const& ctx)
+{
+    set_access_token(ctx);
+
+    return boost::async([this, item_id](){
+        try {
+            Client::Stringlist content_id_list{{item_id}};
+            client_->delete_contents(content_id_list);
+            return make_ready_future();
+        } catch (ParameterInvalidException &e) {
+            return make_exceptional_future<void>(
+                    NotExistsException(string("OnedriveProvider::delete_item(): failed: ") + e.what(), item_id)); 
+        } catch (runtime_error &e) {
+            return make_exceptional_future<void>(
+                    RemoteCommsException(string("OnedriveProvider::delete_item(): failed: ") + e.what())); 
+        }
+    });
+}
+
+boost::future<Item> OnedriveProvider::move(
+    string const& item_id, string const& new_parent_id,
+    string const& /*new_name*/, Context const& ctx)
+{
+    set_access_token(ctx);
+
+    return boost::async([this, item_id, new_parent_id](){
+        try {
+            Client::Stringlist folderlist;
+            Client::Stringlist contentlist{{item_id}};
+            client_->move_items(folderlist, contentlist, new_parent_id);
+            auto content = client_->metadata(item_id);
+            return make_ready_future<Item>(content_to_item(content));
+        } catch (NonExistentException &e) {
+            return make_exceptional_future<Item>(
+                    NotExistsException(string("OnedriveProvider::move(): content or folder not exist: ") + e.what(), "")); 
+        } catch (runtime_error &e) {
+            return make_exceptional_future<Item>(
+                    RemoteCommsException(string("OnedriveProvider::move(): failed: ") + e.what())); 
+        }
+    });
+}
+
+boost::future<Item> OnedriveProvider::copy(
+    string const& item_id, string const& new_parent_id,
+    string const& /*new_name*/, Context const& ctx)
+{
+    set_access_token(ctx);
+
+    return boost::async([this, item_id, new_parent_id](){
+        try {
+            Client::Stringlist content_list{{item_id}};
+            auto content_id = client_->copy_contents(content_list, new_parent_id)[0];
+            auto content = client_->metadata(content_id);
+            return make_ready_future<Item>(content_to_item(content));
+        } catch (NonExistentException &e) {
+            return make_exceptional_future<Item>(
+                    NotExistsException(string("OnedriveProvider::copy(): content or folder not exist: ") + e.what(), item_id)); 
+        } catch (runtime_error &e) {
+            return make_exceptional_future<Item>(
+                    RemoteCommsException(string("OnedriveProvider::copy(): failed: ") + e.what())); 
+        }
+    });
+}
+
+void OnedriveProvider::set_access_token(Context const& ctx) {
+    auto access_token = boost::get<OAuth2Credentials>(ctx.credentials).access_token;
+    std::cout <<"onedrive access_token:  " << access_token << std::endl;
+    client_->set_access_token(access_token);
+}
+
+OnedriveUploadJob::OnedriveUploadJob(string const &upload_id,
+                                 Client::Ptr client,
+                                 string const& parent_id, 
+                                 string const& file_name,
+                                 int64_t     size,
+                                 bool allow_overwrite)
+    : UploadJob(upload_id)
+    , parent_id_(parent_id)
+    , file_name_(file_name)
+    , upload_size_(size)
+    , allow_overwrite_(allow_overwrite)
+    , task_(nullptr)
+    , client_(client) 
+{
+    upload_future_ = upload_data();
+}
+
+boost::future<void> OnedriveUploadJob::cancel()
+{
+    printf("cancel_upload('%s')\n", upload_id().c_str());
+    stop_and_cancel();
+
+    return make_ready_future();
+}
+
+boost::future<Item> OnedriveUploadJob::finish()
+{
+    printf("finish_upload('%s')\n", upload_id().c_str());
+    return boost::async([this](){
+        try {
+            auto upload_ctx = upload_future_.get();
+            auto upload_ok = get<0>(upload_ctx);
+            auto error_str = get<1>(upload_ctx);
+            if (upload_ok){
+                auto content = client_->metadata(task_->content_id());
+                return make_ready_future<Item>(content_to_item(content));
+            }
+
+            return make_exceptional_future<Item>(
+                    RemoteCommsException(string("OnedriveUploadJob::finish(): failed: ") + error_str));
+        } catch (runtime_error &e) {
+            return make_exceptional_future<Item>(
+                    RemoteCommsException(string("OnedriveUploadJob::finish(): failed: ") + e.what()));
+        }
+    });
+}
+
+boost::future<tuple<bool, string>> OnedriveUploadJob::upload_data()
+{
+    auto prom = boost::make_shared<boost::promise<tuple<bool, string>>>();
+
+    return boost::async([this, prom](){
+        std::lock_guard<std::mutex> guard(mutex_);
+
+        int socket_fd = read_socket(); 
+        UploadBufferList buffer_item_list{{[socket_fd](void *dest, size_t buf_size) -> size_t {
+            //data reading callback.
+            size_t read_size =  read(socket_fd, dest, buf_size);			
+            if (read_size == 0)
+                return -1;
+            return read_size;
+        }, (size_t)upload_size_, parent_id_, file_name_}};
+        
+        try {
+            task_ = client_->syncmanager()->add_upload_tasks(buffer_item_list)[0];
+            task_->status_changed() = [this, prom](Task::Status status) {
+                std::cout << " status: " << status_to_string(status) << std::endl;
+                if (status == Task::Status::Complete){
+                    prom->set_value(make_tuple(true, string()));
+                } else if (status == Task::Status::Canceled || 
+                        status == Task::Status::Broken) {
+                    prom->set_value(make_tuple(false, task_->error_string()));
+                }
+            };
+            task_->progress_changed() = [this](float percent) {
+                cout<< "uploading: " << task_->content_name() << "  " << percent << endl;
+            };
+        } catch (runtime_error & e) {
+            prom->set_value(make_tuple(false, e.what()));
+        }
+
+        return prom->get_future();
+    });
+}
+
+void OnedriveUploadJob::stop_and_cancel()
+{
+    std::lock_guard<std::mutex> guard(mutex_);
+
+    if (task_ != nullptr && 
+            (task_->status() != Task::Status::Broken && 
+             task_->status() != Task::Status::Complete)) {
+        task_->cancel();
+    }
+}
+
+OnedriveDownloadJob::OnedriveDownloadJob(string const &download_id,
+                                     string const &item_id,
+                                     Client::Ptr client)
+    : DownloadJob(download_id)
+    , item_id_(item_id)
+    , task_(nullptr)
+    , client_(client) 
+{
+    download_future_ = download_data();
+}
+
+boost::future<void> OnedriveDownloadJob::cancel()
+{
+    stop_and_cancel();
+
+    printf("cancel_download('%s')\n", download_id().c_str());
+    return make_ready_future();
+}
+
+boost::future<void> OnedriveDownloadJob::finish()
+{
+    return boost::async([this]() {
+        auto download_ctx  = download_future_.get();
+        auto download_ok = get<0>(download_ctx);
+        auto error_str   = get<1>(download_ctx);
+        if (download_ok){
+            return make_ready_future();
+        }
+
+        return make_exceptional_future<void>(
+                RemoteCommsException(string("failed to download from onedrive: ") + error_str));
+    });
+}
+
+boost::future<tuple<bool, string>> OnedriveDownloadJob::download_data()
+{
+    auto prom = boost::make_shared<boost::promise<tuple<bool, string>>>();
+
+    return boost::async([this, prom](){
+        std::lock_guard<std::mutex> guard(mutex_);
+
+        int socket_fd = write_socket();
+        DownloadBufferList buffer_item_list{{item_id_, 
+            [socket_fd](void *dest, size_t buf_size) -> size_t {
+                //data writing callback.
+                return write(socket_fd, dest, buf_size);
+            }
+        }};
+
+        try {
+            task_ = client_->syncmanager()->add_download_tasks(buffer_item_list)[0];
+            task_->status_changed() = [this, prom](Task::Status status) {
+                std::cout << " status: " << status_to_string(status) << std::endl;
+                if (status == Task::Status::Complete) {
+                    report_complete();
+                    prom->set_value(make_tuple(true, string()));
+                } else if (status == Task::Status::Canceled || 
+                        status == Task::Status::Broken) {
+                    prom->set_value(make_tuple(false, task_->error_string()));
+                }
+            };
+            task_->progress_changed() = [this](float percent) {
+                cout<< "downloading: " << task_->content_name() << "  " << percent << endl;
+            };
+        } catch (runtime_error & e) {
+            prom->set_value(make_tuple(false, e.what()));
+        }
+
+        return prom->get_future();
+    });
+}
+
+void OnedriveDownloadJob::stop_and_cancel()
+{
+    std::lock_guard<std::mutex> guard(mutex_);
+
+    if (task_ != nullptr && 
+            (task_->status() != Task::Status::Broken && 
+             task_->status() != Task::Status::Complete)) {
+       task_->cancel();
+    }
+}
+
+int main(int argc, char **argv)
+{
+    const std::string bus_name = "com.canonical.StorageFramework.Provider.OnedriveProvider";
+    std::string account_service_id = "com.canonical.scopes.onedrive_onedrive_onedrive";
+    if (argc > 1)
+    { 
+        account_service_id = argv[1];
+    } 
+
+    Server<OnedriveProvider> server(bus_name, account_service_id);
+    server.init(argc, argv);
+    server.run();
+}

=== added file 'provider/OnedriveProvider.h'
--- provider/OnedriveProvider.h	1970-01-01 00:00:00 +0000
+++ provider/OnedriveProvider.h	2016-09-30 08:26:58 +0000
@@ -0,0 +1,74 @@
+/*
+ * Copyright (C) 2016 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authors: Gary Wang <[e-mail]>
+ */
+
+#pragma once
+
+#include <unity/storage/provider/ProviderBase.h>
+#include <onedrive/api/client.h>
+
+using namespace std;
+using namespace onedrive::api;
+using unity::storage::provider::Context;
+using unity::storage::provider::DownloadJob;
+using unity::storage::provider::ProviderBase;
+using unity::storage::provider::Item;
+using unity::storage::provider::ItemList;
+using unity::storage::provider::UploadJob;
+
+class OnedriveProvider : public ProviderBase {
+public:
+    OnedriveProvider();
+      
+    boost::future<ItemList> roots(Context const& ctx) override;
+    boost::future<tuple<ItemList,string>> list(
+          string const& item_id, string const& page_token,
+          Context const& ctx) override;
+    boost::future<ItemList> lookup(
+          string const& parent_id, string const& name,
+          Context const& ctx) override;
+    boost::future<Item> metadata(
+          string const& item_id, Context const& ctx) override;
+    boost::future<Item> create_folder(
+          string const& parent_id, string const& name,
+          Context const& ctx) override;
+      
+    boost::future<unique_ptr<UploadJob>> create_file(
+          string const& parent_id, string const& name,
+          int64_t size, string const& content_type, bool allow_overwrite,
+          Context const& ctx) override;
+    boost::future<unique_ptr<UploadJob>> update(
+          string const& item_id, int64_t size,  string const& old_etag,
+          Context const& ctx) override;
+      
+    boost::future<unique_ptr<DownloadJob>> download(
+          string const& item_id, Context const& ctx) override;
+      
+    boost::future<void> delete_item(
+          string const& item_id, Context const& ctx) override;
+    boost::future<Item> move(
+          string const& item_id, string const& new_parent_id,
+          string const& new_name, Context const& ctx) override;
+    boost::future<Item> copy(
+          string const& item_id, string const& new_parent_id,
+          string const& new_name, Context const& ctx) override;
+  
+private: 
+    void set_access_token(Context const& ctx);
+private:
+    Client::Ptr client_;
+};

=== added file 'provider/com.canonical.StorageFramework.Provider.OnedriveProvider.service'
--- provider/com.canonical.StorageFramework.Provider.OnedriveProvider.service	1970-01-01 00:00:00 +0000
+++ provider/com.canonical.StorageFramework.Provider.OnedriveProvider.service	2016-09-30 08:26:58 +0000
@@ -0,0 +1,3 @@
+[D-BUS Service]
+Name=com.canonical.StorageFramework.Provider.OnedriveProvider
+Exec=/usr/bin/onedrive-provider

=== modified file 'src/CMakeLists.txt'
--- src/CMakeLists.txt	2016-09-26 04:27:03 +0000
+++ src/CMakeLists.txt	2016-09-30 08:26:58 +0000
@@ -17,10 +17,53 @@
 find_package(Boost COMPONENTS regex filesystem system REQUIRED)
 find_package(PkgConfig REQUIRED)
 
-include_directories(${Boost_INCLUDE_DIRS} ${NET_CPP_INCLUDE_DIRS} ${OPENSSL_INCLUDE_DIRS})
-
 pkg_check_modules(JSON_CPP jsoncpp REQUIRED)
 pkg_check_modules(NET_CPP net-cpp>=1.3.0 REQUIRED)
-pkg_check_modules(PROCESS_CPP process-cpp REQUIRED)
+
+include_directories(${Boost_INCLUDE_DIRS} ${JSON_CPP_INCLUDE_DIRS} ${NET_CPP_INCLUDE_DIRS}) 
+
+add_library(
+  onedrive-provider SHARED
+
+  ${ONEDRIVE_PROVIDER_LIB_INTERFACE_HEADERS}
+
+  onedrive/api/client.cpp
+  onedrive/api/client_priv.cpp
+  onedrive/api/cloudfolder.cpp
+  onedrive/api/clouditem.cpp
+  onedrive/api/downloadtask.cpp
+  onedrive/api/downloadtask_priv.cpp
+  onedrive/api/uploadtask.cpp
+  onedrive/api/uploadtask_priv.cpp
+  onedrive/api/syncmanager.cpp
+  onedrive/api/syncmanager_priv.cpp
+  onedrive/api/syncthread.cpp
+  onedrive/api/storageinfo.cpp
+  onedrive/api/client.cpp
+)
+
+target_link_libraries(
+  onedrive-provider
+
+  ${CMAKE_THREAD_LIBS_INIT}
+
+  ${Boost_LIBRARIES}
+  ${JSON_CPP_LIBRARIES}
+  ${NET_CPP_LDFLAGS}
+)
 
 set(symbol_map "${CMAKE_SOURCE_DIR}/symbols.map")
+set_target_properties(
+  onedrive-provider
+
+  PROPERTIES
+  LINK_FLAGS "${ldflags} -Wl,--version-script,${symbol_map}"
+  LINK_DEPENDS ${symbol_map}
+  VERSION ${ONEDRIVE_PROVIDER_LIB_VERSION_MAJOR}.${ONEDRIVE_PROVIDER_LIB_VERSION_MINOR}.${ONEDRIVE_PROVIDER_LIB_VERSION_PATCH}
+  SOVERSION ${ONEDRIVE_PROVIDER_LIB_VERSION_MAJOR}
+)
+
+install(
+  TARGETS onedrive-provider
+  LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+)

=== added file 'src/onedrive/api/client.cpp'
--- src/onedrive/api/client.cpp	1970-01-01 00:00:00 +0000
+++ src/onedrive/api/client.cpp	2016-09-30 08:26:58 +0000
@@ -0,0 +1,106 @@
+/*
+ * Copyright © 2016 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Gary Wang <[e-mail]>
+ */
+
+#include <onedrive/api/client.h>
+#include "client_priv.h"
+
+#include <core/net/error.h>
+#include <core/net/uri.h>
+#include <core/net/http/client.h>
+#include <core/net/http/request.h>
+#include <core/net/http/response.h>
+
+#include <boost/filesystem.hpp>
+#include <boost/algorithm/string.hpp>
+
+using namespace onedrive::api;
+using namespace std;
+
+Client::Client(int request_timeout)
+    : p(std::make_shared<ClientPriv>(request_timeout)) {
+
+}
+
+Client::~Client() {
+    p->sync_manager()->cancel();
+}
+
+void Client::set_access_token(const string &access_token) {
+    p->set_access_token(access_token);
+//    p->sync_manager()-
+}
+
+StorageInfo Client::storage_info() {
+    return p->storage_info();
+}
+
+CloudFolder::Ptr Client::root_folder() {
+    return p->root_folder();
+}
+
+tuple<Client::ResourceList, string> Client::cloud_content_list(const std::string &folder_id,
+                                                               const std::string &page_token) {
+    return p->cloud_content_list(folder_id, page_token);
+}
+
+CloudResource::Ptr Client::metadata(const string &content_id) {
+    return p->metadata(content_id);
+}
+
+CloudFolder::Ptr Client::create_folder(const string &folder_name,
+                                       const string &folder_id) {
+    return p->create_folder(folder_name, folder_id);
+}
+
+Client::ResourceList Client::search(const string &name,
+                                    const string &parent_folder_id) {
+    return p->search(name, parent_folder_id);
+}
+
+CloudResource::Ptr  Client::move_item(const std::string &item_id, 
+                                      const std::string &folder_id,
+                                      const std::string &item_name) {
+    return p->move_item(item_id, folder_id, item_name);
+}
+
+bool Client::delete_item(const string &content_id) {
+    return p->delete_item(content_id);
+}
+
+/*
+CloudResource::Ptr Client::copy_item(const string &item_id,
+                                     const string &name,
+                                     const string &folder_id) {
+    return p->copy_item(item_id, name, folder_id);
+}
+*/
+
+CloudResource::Ptr Client::rename_item(const string &item_id,
+                                       const string &name) {
+    return p->rename_item(item_id, name);
+}
+
+//bool Client::refresh_token(const string &refresh_token) {
+//    return p->refersh_token(refresh_token);
+//}
+
+SyncManager::Ptr Client::syncmanager() const {
+    return p->sync_manager();
+}
+
+

=== added file 'src/onedrive/api/client_priv.cpp'
--- src/onedrive/api/client_priv.cpp	1970-01-01 00:00:00 +0000
+++ src/onedrive/api/client_priv.cpp	2016-09-30 08:26:58 +0000
@@ -0,0 +1,780 @@
+/*
+ * Copyright © 2016 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Gary Wang <[e-mail]>
+ */
+
+#include "client_priv.h"
+#include "syncmanager_priv.h"
+#include "config.h"
+
+#include <onedrive/api/cloudfolder.h>
+#include <onedrive/api/clouditem.h>
+#include <onedrive/api/storageinfo.h>
+#include <onedrive/api/downloadtask.h>
+#include <onedrive/api/uploadtask.h>
+#include <onedrive/api/cloudresource.h>
+#include <onedrive/api/syncmanager.h>
+#include <onedrive/api/exceptions.h>
+
+#include <core/net/error.h>
+#include <core/net/uri.h>
+#include <core/net/http/client.h>
+#include <core/net/http/request.h>
+#include <core/net/http/response.h>
+
+#include <boost/algorithm/string.hpp>
+#include <boost/algorithm/string/regex.hpp>
+#include <boost/filesystem.hpp>
+#include <boost/regex.hpp>
+
+#include <json/json.h>
+
+#include <iostream>
+#include <unordered_map>
+
+namespace http = core::net::http;
+namespace json = Json;
+namespace net = core::net;
+
+namespace fs = boost::filesystem;
+namespace alg = boost::algorithm;
+
+using namespace onedrive::api;
+using namespace std;
+
+namespace {
+
+template<typename T>
+static void set_exception(std::shared_ptr<std::promise<T>> prom,
+                          const json::Value &root) {
+    if (root.isMember("error")) {
+        std::string code = root["error"]["code"].asString();
+        std::string msg  = root["error"]["message"].asString();
+        if (code == "unauthenticated") {
+            prom->set_exception(make_exception_ptr(CredentialException(msg)));
+        } else if (code == "itemNotFound") {
+            prom->set_exception(make_exception_ptr(NonExistentException(msg)));
+        } else if (code == "invalidRequest") {
+            prom->set_exception(make_exception_ptr(ParameterInvalidException(msg)));
+        } else if (code == "quotaLimitReached") {
+            prom->set_exception(make_exception_ptr(CredentialException(msg)));
+        } else if (code == "serviceNotAvailable") {
+            prom->set_exception(make_exception_ptr(ServiceNotAvailableException(msg)));
+        }
+
+        return;
+    }
+
+    prom->set_exception(make_exception_ptr(UnknownException(root.toStyledString())));
+}
+
+}
+
+class ClientPriv::HttpClient {
+public:
+    HttpClient(int request_timeout) :
+        client_(http::make_client()),
+        worker_ { [this]() {client_->run();} },
+        cancelled_(false) {
+        config_.request_timeout = request_timeout;
+    }
+
+    ~HttpClient() {
+        client_->stop();
+        if (worker_.joinable()) {
+            worker_.join();
+        }
+    }
+
+    std::shared_ptr<core::net::http::Client> client_;
+
+    std::thread worker_;
+
+    Config config_;
+
+    std::mutex config_mutex_;
+
+    std::atomic<bool> cancelled_;
+
+    void get(const net::Uri::Path &path,
+            const net::Uri::QueryParameters &parameters,
+            http::Request::Handler &handler) {
+        auto configuration = net_config(path, parameters);
+        configuration.header.add("User-Agent", config_.user_agent);
+
+        auto request = client_->head(configuration);
+        request->async_execute(handler);
+    }
+
+    void post(const net::Uri::Path &path,
+            const net::Uri::QueryParameters &parameters,
+            const std::string &postbody,
+            const std::string &content_type,
+            http::Request::Handler &handler) {
+        std::lock_guard<std::mutex> lock(config_mutex_);
+        http::Request::Configuration configuration = net_config(path, parameters);
+        configuration.header.add("User-Agent", config_.user_agent);
+        configuration.header.add("Content-Length", std::to_string(postbody.size()));
+        configuration.header.add("Content-Type", content_type);
+        configuration.header.add("Prefer", "respond-async");
+
+        auto request = client_->post(configuration, postbody, content_type);
+        request->async_execute(handler);
+    }
+
+    void del(const net::Uri::Path &path,
+            const net::Uri::QueryParameters &parameters,
+            http::Request::Handler &handler) {
+        std::lock_guard<std::mutex> lock(config_mutex_);
+        http::Request::Configuration configuration = net_config(path, parameters);
+        configuration.header.add("User-Agent", config_.user_agent);
+
+        auto request = client_->del(configuration);
+        request->async_execute(handler);
+    }
+
+    void patch(const net::Uri::Path &path,
+            const net::Uri::QueryParameters &parameters,
+            const std::string &postbody,
+            const std::string &content_type,
+            http::Request::Handler &handler) {
+        std::lock_guard<std::mutex> lock(config_mutex_);
+        http::Request::Configuration configuration = net_config(path, parameters);
+        configuration.header.add("User-Agent", config_.user_agent);
+        configuration.header.add("Content-Type", content_type);
+        //WORKAROUND: net-cpp doesn't support PATCH method.
+        configuration.header.add("X-HTTP-Method-Override", "PATCH");
+
+        auto request = client_->post(configuration, postbody, content_type);
+        request->async_execute(handler);
+    }
+
+    http::Request::Configuration net_config(const net::Uri::Path &path,
+                                            const net::Uri::QueryParameters &parameters) {
+        http::Request::Configuration configuration;
+        net::Uri::QueryParameters complete_parameters(parameters);
+        if (!config_.access_token.empty()) {
+            configuration.header.add("Authorization",
+                    "bearer " + config_.access_token);
+        }
+
+        if (getenv("ONEDRIVE_LOCAL_SERVER_URL")) {
+            config_.apiroot = string(getenv("ONEDRIVE_LOCAL_SERVER_URL"));
+            configuration.header.add("Authorization",
+                    "bearer " + config_.access_token);
+        }
+
+        net::Uri uri = net::make_uri(config_.apiroot, path,
+                complete_parameters);
+        configuration.uri = client_->uri_to_string(uri);
+        std::cout << "uri: "<<configuration.uri << std::endl;
+
+        return configuration;
+    }
+
+    http::Request::Progress::Next progress_changed(
+            const http::Request::Progress&) {
+        return cancelled_ ?
+                http::Request::Progress::Next::abort_operation :
+                http::Request::Progress::Next::continue_operation;
+    }
+
+    template<typename T>
+    future<T> async_get(const net::Uri::Path &path,
+            const net::Uri::QueryParameters &parameters,
+            const function<T(const json::Value &root)> &func) {
+        auto prom = make_shared<promise<T>>();
+
+        http::Request::Handler handler;
+        handler.on_progress(
+                bind(&ClientPriv::HttpClient::progress_changed, this, placeholders::_1));
+        handler.on_error([prom](const net::Error& e)
+        {
+            prom->set_exception(make_exception_ptr(runtime_error(e.what())));
+        });
+        handler.on_response(
+            [prom,func](const http::Response& response)
+            {
+                json::Reader reader;
+                json::Value  root;
+
+                std::cout <<"http status code: " << response.status <<"response.body: " << response.body
+                            << std::endl;
+
+                //for download link generation, link can be found at header[location] according to dev doc
+                if (response.status == net::http::Status::accepted) {
+                    response.header.enumerate([&root](const std::string& key,
+                                                const std::set<std::string>& /*values*/) {
+                        vector<string> headers;
+                        boost::split_regex(headers, key, boost::regex(": "));
+                        boost::trim_right(headers[1]);
+                        root[headers[0]] = headers[1];
+                        std::cout << "header: " << key <<"    " << headers[1] << std::endl;
+                    });
+                    prom->set_value(func(root));
+                } else if (!reader.parse(response.body, root)) {
+                    prom->set_exception(make_exception_ptr(UnknownException("json parse failed")));
+                } else {
+                    if (response.status != net::http::Status::ok) {
+                        set_exception<T>(prom, root);
+                    } else {
+                        prom->set_value(func(root));
+                    }
+                }
+            }
+        );
+
+        get(path, parameters, handler);
+
+        return prom->get_future();
+    }
+
+    template<typename T>
+    future<T> async_post(const net::Uri::Path &path,
+            const net::Uri::QueryParameters &parameters,
+            const std::string &postmsg,
+            const std::string &content_type,
+            const function<T(const json::Value &root)> &func) {
+        auto prom = make_shared<promise<T>>();
+
+        http::Request::Handler handler;
+        handler.on_progress(
+                bind(&ClientPriv::HttpClient::progress_changed, this, placeholders::_1));
+        handler.on_error([prom](const net::Error& e)
+        {
+            prom->set_exception(make_exception_ptr(runtime_error(e.what())));
+        });
+        handler.on_response(
+            [path, prom,func](const http::Response& response)
+            {
+                json::Reader reader;
+                json::Value  root;
+
+                std::cout <<"http status code: " << response.status <<"response.body: " << response.body
+                         <<"   isempty: " <<response.body.empty() << std::endl;
+
+                if (!reader.parse(response.body, root)) {
+                    prom->set_exception(make_exception_ptr(runtime_error("json parse failed")));
+                } else if (response.status != net::http::Status::ok &&
+                        response.status != net::http::Status::created  &&
+                        response.status != net::http::Status::accepted &&
+                        response.status != net::http::Status::see_other) {
+                    set_exception<T>(prom, root);
+                } else {
+                    //To deal with AsyncJobStatus
+                    //https://dev.onedrive.com/items/copy.htm
+                    string cache_header;
+                    if (response.status == net::http::Status::accepted) {
+                        json::Value requestJson;
+                        json::StyledWriter writer;
+                        response.header.enumerate([&requestJson, &cache_header,
+                                                   &writer](const std::string& key,
+                                                            const std::set<std::string>& /*values*/) {
+                            vector<string> headers;
+                            boost::split_regex(headers, key, boost::regex(": "));
+                            boost::trim_right(headers[1]);
+                            requestJson[headers[0]] = headers[1];
+                            std::cout << "sdfsdfsd: " << key <<"    " << headers[1] << std::endl;
+                        });
+
+                        cache_header = writer.write(requestJson);
+//                        return;
+                    }
+
+                    if (!cache_header.empty() && !reader.parse(cache_header, root)) {
+                        prom->set_exception(make_exception_ptr(runtime_error("json parse failed")));
+                    } else {
+                        prom->set_value(func(root));
+                    }
+                }
+            }
+        );
+
+        post(path, parameters, postmsg, content_type, handler);
+
+        return prom->get_future();
+    }
+
+    template<typename T>
+    future<T> async_patch(const net::Uri::Path &path,
+            const net::Uri::QueryParameters &parameters,
+            const std::string &postmsg,
+            const std::string &content_type,
+            const function<T(const json::Value &root)> &func) {
+        auto prom = make_shared<promise<T>>();
+
+        http::Request::Handler handler;
+        handler.on_progress(
+                bind(&ClientPriv::HttpClient::progress_changed, this, placeholders::_1));
+        handler.on_error([prom](const net::Error& e)
+        {
+            prom->set_exception(make_exception_ptr(runtime_error(e.what())));
+        });
+        handler.on_response(
+            [path, prom,func](const http::Response& response)
+            {
+                json::Reader reader;
+                json::Value  root;
+
+                std::cout <<"http status code: " << response.status <<"response.body: " << response.body
+                         <<"   isempty: " <<response.body.empty() << std::endl;
+
+                if (!reader.parse(response.body, root)) {
+                    prom->set_exception(make_exception_ptr(UnknownException("json parse failed")));
+                } else {
+                    if (response.status != net::http::Status::ok) {
+                        set_exception<T>(prom, root);
+                    } else {
+                        prom->set_value(func(root));
+                    }
+                }
+            }
+        );
+
+        patch(path, parameters, postmsg, content_type, handler);
+
+        return prom->get_future();
+    }
+
+    template<typename T>
+    future<T> async_del(const net::Uri::Path &path,
+            const net::Uri::QueryParameters &parameters,
+            const function<T(const json::Value &root)> &func) {
+        auto prom = make_shared<promise<T>>();
+
+        http::Request::Handler handler;
+        handler.on_progress(
+                bind(&ClientPriv::HttpClient::progress_changed, this, placeholders::_1));
+        handler.on_error([prom](const net::Error& e)
+        {
+            prom->set_exception(make_exception_ptr(runtime_error(e.what())));
+        });
+        handler.on_response(
+            [prom,func](const http::Response& response)
+            {
+                std::cout <<"http status code: " << response.status <<"response.body: " << response.body
+                            << std::endl;
+
+                json::Reader reader;
+                json::Value  root;
+                if (response.status == net::http::Status::no_content) {
+                    prom->set_value(func(root));
+                } else {
+                    if (!reader.parse(response.body, root)) {
+                        prom->set_exception(make_exception_ptr(UnknownException("json parse failed")));
+                    } else{
+                       set_exception<T>(prom, root);
+                    }
+                }
+            }
+        );
+
+        del(path, parameters, handler);
+
+        return prom->get_future();
+    }
+};
+
+ClientPriv::ClientPriv(int request_timeout)
+    : httpclient_(std::make_shared<HttpClient>(request_timeout))
+    , sync_manager_(std::shared_ptr<SyncManager>(new SyncManager(this))) {
+}
+
+ClientPriv::~ClientPriv() {
+    httpclient_->cancelled_ = true;
+}
+
+void ClientPriv::set_access_token(const string &access_token) {
+    httpclient_->config_.access_token = access_token;
+    sync_manager_->p_->set_access_token(access_token);
+}
+
+StorageInfo ClientPriv::storage_info() {
+    auto storage_future = httpclient_->async_get<StorageInfo>(
+    { "drive" }, { }, 
+    [](const json::Value &root) {
+        return StorageInfo(root);
+    });
+
+    return get_or_throw(storage_future);
+}
+
+CloudResource::Ptr ClientPriv::metadata(const string &content_id) {
+    auto disk_future = httpclient_->async_get<CloudResource::Ptr>(
+    { "drive",  "items", content_id }, { },
+    [](const json::Value &root) -> CloudResource::Ptr {
+        if (root.isMember("folder"))
+            return shared_ptr<CloudFolder>(new CloudFolder(root));
+        return shared_ptr<CloudItem>(new CloudItem(root));
+    });
+
+    return get_or_throw(disk_future);
+}
+
+CloudFolder::Ptr ClientPriv::root_folder() {
+    auto folder_future = httpclient_->async_get<CloudFolder::Ptr>(
+    { "drive",  "items", "root" }, { },
+    [](const json::Value &root) -> CloudFolder::Ptr {
+        return shared_ptr<CloudFolder>(new CloudFolder(root));
+    });
+
+    return get_or_throw(folder_future);
+}
+
+tuple<Client::ResourceList, string> ClientPriv::cloud_content_list(const std::string &folder_id,
+                                                                   const std::string &page_token) {
+    net::Uri::Path path { "drive", "items" };
+    if (folder_id.empty()) {
+        path.emplace_back("root");
+    } else {
+        path.emplace_back(folder_id);
+    }
+
+    net::Uri::QueryParameters params { { "expand", "children" } };
+    if (!page_token.empty()) {
+        params.emplace_back(make_pair("skiptoken", page_token));
+    }
+
+    auto resource_future = httpclient_->async_get<tuple<Client::ResourceList, string>>(
+        path, params, 
+        [](const json::Value &root) -> tuple<Client::ResourceList, string> {
+        Client::ResourceList results;
+
+        json::Value children;
+        if (root.isMember("children"))
+            children = root["children"];
+        else if (root.isMember("value"))
+            children = root["value"];
+
+        for (const auto & child: children) {
+            if (child.isMember("folder")) {
+                results.push_back(std::shared_ptr<CloudFolder>(new CloudFolder(child)));
+            } else {
+                results.push_back(std::shared_ptr<CloudItem>(new CloudItem(child)));
+            }
+        }
+
+        string next_page_token;
+        if (root.isMember("[e-mail]")) {
+            const string nextToken = "skiptoken";
+            string nextLink = root["[e-mail]"].asString();
+            size_t pos = nextLink.find(nextToken) + nextToken.length();
+            next_page_token = nextLink.substr(pos);
+        }
+
+        return make_tuple(results, next_page_token);
+    });
+
+    return get_or_throw(resource_future);
+}
+
+Client::ResourceList ClientPriv::search(const string &name,
+                                        const string &folder_id) {
+    net::Uri::Path path { "drive", "items" };
+    if (folder_id.empty()) {
+        path.emplace_back("root");
+    } else {
+        path.emplace_back(folder_id);
+    }
+    path.emplace_back("view.search");
+
+    auto resource_future = httpclient_->async_get<Client::ResourceList>(
+        path, {{"q", name}}, 
+        [](const json::Value &root) -> Client::ResourceList {
+        Client::ResourceList results;
+
+        json::Value children;
+        if (root.isMember("children"))
+            children = root["children"];
+        else if (root.isMember("value"))
+            children = root["value"];
+        for (const auto & child: children) {
+            if (child.isMember("folder")) {
+                results.push_back(std::shared_ptr<CloudFolder>(new CloudFolder(child)));
+            } else {
+                results.push_back(std::shared_ptr<CloudItem>(new CloudItem(child)));
+            }
+        }
+
+        return results;
+    });
+
+    return get_or_throw(resource_future);
+}
+
+CloudFolder::Ptr ClientPriv::create_folder(const string &folder_name,
+                                           const string &folder_id) {
+    net::Uri::Path path { "drive", "items" };
+    if (folder_id.empty()) {
+        path.emplace_back("root");
+    } else {
+        path.emplace_back(folder_id);
+    }
+    path.emplace_back("children");
+
+    json::Value requestJson;
+    requestJson["name"] = folder_name;
+    requestJson["folder"] = json::Value(json::objectValue);
+
+    json::StyledWriter writer;
+    std::string postbody = writer.write( requestJson );
+    std::string content_type = "application/json";
+    std::cout << "postbody:  " << postbody << std::endl;
+
+    auto created = httpclient_->async_post<CloudFolder::Ptr>(path,
+            { }, postbody, content_type,
+            [](const json::Value &root) -> CloudFolder::Ptr {
+                return shared_ptr<CloudFolder>(new CloudFolder(root));
+            });
+
+    return get_or_throw(created);
+}
+
+bool ClientPriv::delete_item(const string item_id) {
+    auto del = httpclient_->async_del<bool>(
+            { "drive", "items", item_id }, { },
+            [](const json::Value &root) -> bool {
+                return root.isNull() ? true : false;
+            });
+
+    return get_or_throw(del);
+}
+
+/*
+CloudResource::Ptr ClientPriv::copy_item(const std::string &item_id,
+                                         const std::string &item_name,
+                                         const std::string &folder_id) {
+    json::Value requestJson;
+    requestJson["parentReference"]["id"] = folder_id;
+    requestJson["name"] = item_name;
+
+    json::StyledWriter writer;
+    std::string postbody = writer.write( requestJson );
+    std::string content_type = "application/json";
+    std::cout << "postbody:  " << postbody << std::endl;
+
+    auto copy = httpclient_->async_post<unordered_map<string, string>>(
+            { "drive", "items", item_id, "action.copy"}, { }, postbody, content_type,
+            [](const json::Value &root) -> unordered_map<string, string> {
+            unordered_map<string, string> map{
+                {"Content-Length", root["Content-Length"].asString()},
+                {"Location", root["Location"].asString()},
+                {"Preference-Applied", root["Preference-Applied"].asString()},
+                {"Server", root["Preference-Applied"].asString()},
+                {"X-Msnserver", root["X-Msnserver"].asString()},
+                {"X-Wlsproxy", root["X-Wlsproxy"].asString()}
+            };
+            return map;
+            });
+
+    auto cache_header = get_or_throw(copy);
+    for (const auto & c: cache_header) {
+        std::cout << c.first  << "   "<< c.second << std::endl;
+    }
+
+    auto ePos = cache_header["Location"].find_last_of('/');
+    auto sub_path = cache_header["Location"].substr(ePos + 1);
+
+    std::cout << "cache_header.size():"  << cache_header.size() << "   "<< cache_header["Location"] << "  "
+              << sub_path << std::endl;
+    if (!cache_header.empty()) {
+        auto check_future = httpclient_->async_get<CloudResource::Ptr>(
+        { "monitor",  sub_path}, { }, cache_header,
+        [](const json::Value &root) -> CloudResource::Ptr {
+            return root.isNull()? nullptr : nullptr;
+        });
+
+        CloudResource::Ptr ptr = get_or_throw(check_future);
+        Client::ResourceList resourceList = search(item_name, folder_id);
+        if (resourceList.size() > 0)
+            return resourceList[0];
+    }
+
+    throw runtime_error("item copy failed");
+}
+*/
+
+
+CloudResource::Ptr  ClientPriv::move_item(const std::string &item_id,
+                                          const std::string &folder_id,
+                                          const std::string &item_name) {
+    json::Value requestJson;
+    requestJson["parentReference"]["id"] = folder_id;
+    if (!item_name.empty())
+        requestJson["name"] = item_name;
+
+    json::StyledWriter writer;
+    std::string postbody = writer.write(requestJson);
+    std::string content_type = "application/json";
+
+    auto move_future = httpclient_->async_patch<CloudResource::Ptr>(
+        { "drive", "items", item_id }, { },postbody, content_type,
+        [](const json::Value &root) -> CloudResource::Ptr {
+        if (root.isMember("folder"))
+            return shared_ptr<CloudFolder>(new CloudFolder(root));
+        return shared_ptr<CloudItem>(new CloudItem(root));
+    });
+
+    return get_or_throw(move_future);
+}
+
+CloudResource::Ptr ClientPriv::rename_item(const string &item_id, const string &new_name) {
+    json::Value requestJson;
+    requestJson["name"] = new_name;
+
+    json::StyledWriter writer;
+    std::string postbody = writer.write(requestJson);
+    std::string content_type = "application/json";
+
+    auto move_future = httpclient_->async_patch<CloudResource::Ptr>(
+        { "drive", "items", item_id }, { }, postbody, content_type,
+        [](const json::Value &root) -> CloudResource::Ptr {
+        if (root.isMember("folder"))
+            return shared_ptr<CloudFolder>(new CloudFolder(root));
+        return shared_ptr<CloudItem>(new CloudItem(root));
+    });
+
+    return get_or_throw(move_future);
+}
+
+string ClientPriv::request_download_link(const string &item_id) {
+    auto link_future = httpclient_->async_get<string>(
+    { "drive",  "items", item_id, "content" }, { },
+    [](const json::Value &root) -> string {
+        return root["location"].asString();
+    });
+
+    return get_or_throw(link_future);
+}
+
+//DownloadTaskPriv::Ptr ClientPriv::request_download_link(const DownloadBuffer &buffer_item) {
+
+//}
+
+/*
+SyncManager::UploadList ClientPriv::create_upload_link(const UploadRequest &request_item) {
+    if (!fs::exists(request_item.file_path)) 
+        throw std::runtime_error(string("file not exists: ").append(request_item.file_path));
+                            
+    string postbody = generate_upload_body(request_item);
+
+    log(postbody);
+
+    auto future = httpclient_->async_post<SyncManager::UploadList>(
+            { "richlifeApp", "devapp", "IUploadAndDownload" }, { }, postbody, content_type,
+            [request_item](const tinyxml2::XMLElement *root) {
+        SyncManager::UploadList results;
+
+        auto upload_res = root->FirstChildElement("uploadResult");
+        std::string task_id = upload_res->FirstChildElement("uploadTaskID")->GetText();
+
+        std::string redirection_url;
+        if (upload_res->FirstChildElement("redirectionUrl")) {
+            redirection_url = upload_res->FirstChildElement("redirectionUrl")->GetText();
+        }
+
+        auto content_list = upload_res->FirstChildElement("newContentIDList");
+        if (content_list) {
+            auto content = content_list->FirstChildElement();
+            while(content) {
+                results.push(std::shared_ptr<UploadTask>(new UploadTask(content,
+                                                                        task_id,
+                                                                        redirection_url,
+                                                                        request_item.file_path)));
+                content = content->NextSiblingElement();
+            }
+        }
+
+        return results;
+    });
+
+    return get_or_throw(future);
+}
+
+SyncManager::UploadList ClientPriv::create_upload_link(const UploadBuffer &buffer_item) {
+    string postbody = generate_upload_body(buffer_item);
+
+    log(postbody);
+
+    auto future = httpclient_->async_post<SyncManager::UploadList>(
+            { "richlifeApp", "devapp", "IUploadAndDownload" }, { }, postbody, content_type,
+            [buffer_item](const tinyxml2::XMLElement *root) {
+        SyncManager::UploadList results;
+
+        auto upload_res = root->FirstChildElement("uploadResult");
+        std::string task_id = upload_res->FirstChildElement("uploadTaskID")->GetText();
+
+        std::string redirection_url;
+        if (upload_res->FirstChildElement("redirectionUrl")) {
+            redirection_url = upload_res->FirstChildElement("redirectionUrl")->GetText();
+        }
+
+        auto content_list = upload_res->FirstChildElement("newContentIDList");
+        if (content_list) {
+            auto content = content_list->FirstChildElement();
+            while(content) {
+                results.push(std::shared_ptr<UploadTask>(new UploadTask(content,
+                                                                        task_id,
+                                                                        redirection_url,
+                                                                        buffer_item.buffer_size,
+                                                                        buffer_item.read_cb)));
+                content = content->NextSiblingElement();
+            }
+        }
+
+        return results;
+    });
+
+    return get_or_throw(future);
+}
+
+bool ClientPriv::refersh_token(const string &refresh_token) {
+    const std::string content_type = "application/x-www-form-urlencoded";
+    const std::string postbody = "grant_type=refresh_token&refresh_token="
+                                    + refresh_token;
+    log(postbody);
+
+    auto future = httpclient_->async_post<bool>(
+            { "oauthApp", "OAuth2", "refreshToken" }, { }, postbody, content_type,
+            [this](const tinyxml2::XMLElement *root) {
+        boost::cmatch cap;
+        const boost::regex exp(".*\"(.*?)\"\\}");
+        if (boost::regex_match(root->GetText(), cap, exp)) {
+            httpclient_->config_.access_token = cap[1];
+            return true;
+        }
+        return false;
+    });
+
+    return get_or_throw(future);
+}
+*/
+
+void ClientPriv::cancel() {
+    httpclient_->cancelled_ = true;
+}
+
+SyncManager::Ptr ClientPriv::sync_manager() {
+    return sync_manager_;
+}
+
+template<typename T> T ClientPriv::get_or_throw(std::future<T> &f) {
+    if (f.wait_for(std::chrono::seconds(httpclient_->config_.request_timeout)) != std::future_status::ready) {
+        throw HttpTimeoutException("HTTP request timeout");
+    }
+
+    return f.get();
+}

=== added file 'src/onedrive/api/client_priv.h'
--- src/onedrive/api/client_priv.h	1970-01-01 00:00:00 +0000
+++ src/onedrive/api/client_priv.h	2016-09-30 08:26:58 +0000
@@ -0,0 +1,106 @@
+/*
+ * Copyright (C) 2016 Canonical, Ltd.
+ *
+ * This library is free software; you can redistribute it and/or modify it under
+ * the terms of version 3 of the GNU Lesser General Public License as published
+ * by the Free Software Foundation.
+ *
+ * This library is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
+ * details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by:  Gary Wang <[e-mail]>
+ */
+
+#ifndef ONEDRIVE_API_CLIENTPRIV_H_
+#define ONEDRIVE_API_CLIENTPRIV_H_
+
+#include <onedrive/api/client.h>
+#include <onedrive/api/visibility.h>
+#include <onedrive/api/cloudresource.h>
+
+#include <future>
+#include <string>
+#include <memory>
+
+#include "downloadtask_priv.h"
+#include "uploadtask_priv.h"
+
+namespace onedrive {
+namespace api {
+
+class Client;
+
+class ONEDRIVE_API_DLL_LOCAL ClientPriv {
+  public:
+
+    enum class ServerCode {
+    };
+
+    typedef std::shared_ptr<ClientPriv> Ptr;
+
+    ClientPriv(int request_timeout = 10);
+
+    virtual ~ClientPriv();
+
+    StorageInfo storage_info();
+
+    void set_access_token(const std::string &access_token);
+
+//    bool refersh_token(const std::string &refresh_token);
+
+    CloudResource::Ptr   metadata(const std::string &content_id);
+
+    CloudFolder::Ptr root_folder();
+
+    std::tuple<Client::ResourceList, std::string> cloud_content_list(const std::string &folder_id = std::string(),
+                                                                     const std::string &page_token = std::string());
+
+    Client::ResourceList search(const std::string &name,
+                                const std::string &folder_id);
+
+    CloudFolder::Ptr create_folder(const std::string &folder_name,
+                                   const std::string &folder_id);
+
+    /*
+    CloudResource::Ptr copy_item(const std::string &item_id,
+                                 const std::string &item_name,
+                                 const std::string &folder_id);
+    */
+
+    CloudResource::Ptr move_item(const std::string &item_id,
+                                 const std::string &folder_id,
+                                 const std::string &item_name);
+
+    CloudResource::Ptr rename_item(const std::string &item_id,
+                                   const std::string &new_name);
+
+
+    bool delete_item(const std::string item_id);
+
+    std::string request_download_link(const std::string  &item_id);
+
+//    DownloadTaskPriv::Ptr request_download_link(const DownloadBuffer  &buffer_item);
+
+    void cancel();
+
+    std::shared_ptr<SyncManager> sync_manager();
+
+  private:
+    template<typename T> T get_or_throw(std::future<T> &f);
+
+  private:
+    class HttpClient;
+    std::shared_ptr<HttpClient>  httpclient_;
+
+    std::shared_ptr<SyncManager> sync_manager_;
+};
+
+}
+}
+
+#endif // ONEDRIVE_API_CLIENTPRIV_H_

=== added file 'src/onedrive/api/cloudfolder.cpp'
--- src/onedrive/api/cloudfolder.cpp	1970-01-01 00:00:00 +0000
+++ src/onedrive/api/cloudfolder.cpp	2016-09-30 08:26:58 +0000
@@ -0,0 +1,121 @@
+/*
+ * Copyright © 2016 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Gary Wang <[e-mail]>
+ */
+
+#include <onedrive/api/cloudfolder.h>
+
+#include <json/json.h>
+
+#include <time.h>
+#include <iostream>
+#include <sstream>
+
+namespace json = Json;
+
+using namespace onedrive::api;
+using namespace std;
+
+std::time_t string_to_time(const std::string dt) {
+    struct std::tm tm;
+    std::istringstream ss(dt);
+    strptime(dt.c_str(), "%Y%m%d%H%M%S",&tm); // std::get std::put only available in GCC 5
+    return std::mktime(&tm);
+}
+
+class CloudFolder::Priv {
+public:
+    Priv(const json::Value &root) {
+        id_ = root["id"].asString();
+        updated_date_ = string_to_time(root["lastModifiedDateTime"].asString());
+        created_date_ = string_to_time(root["createdDateTime"].asString());
+        etag_  = root["eTag"].asString();
+        name_  = root["name"].asString();
+        owner_ = root["createdBy"]["user"]["displayName"].asString();
+        folder_id_ = root.isMember("parentReference")?
+                     root["parentReference"]["id"].asString() : "";
+        children_count_ = root["folder"]["childCount"].asInt();
+
+    #ifndef NDEBUG
+        cout << "id: "<< id_ << " name: " << name_ << "  etag: "<< etag_ << endl;
+    #endif
+
+    }
+
+    std::string id_;
+
+    std::string name_;
+
+    std::time_t created_date_;
+
+    std::time_t updated_date_;
+
+    std::string download_url_;
+
+    std::string folder_id_;
+
+    std::string etag_;
+
+    std::string owner_;
+
+    std::string folder_path_;
+
+    int children_count_;
+};
+
+CloudFolder::CloudFolder(const json::Value &root)
+    :p(std::make_shared<Priv>(root)){
+}
+
+const string &CloudFolder::id() const {
+    return p->id_;
+}
+
+const string &CloudFolder::name() const {
+    return p->name_;
+}
+
+const time_t &CloudFolder::created_date() const {
+    return p->created_date_;
+}
+
+const time_t &CloudFolder::updated_date() const {
+    return p->updated_date_;
+}
+
+const string &CloudFolder::download_url() const {
+    return p->download_url_;
+}
+
+const string &CloudFolder::folder_id() const {
+    return p->folder_id_;
+}
+
+const string &CloudFolder::folder_path() const {
+    return p->folder_path_;
+}
+
+const string &CloudFolder::etag() const {
+    return p->etag_;
+}
+
+const string &CloudFolder::owner() const {
+    return p->owner_;
+}
+
+CloudResource::Property CloudFolder::property() const {
+    return CloudResource::Property::Folder;
+}

=== added file 'src/onedrive/api/clouditem.cpp'
--- src/onedrive/api/clouditem.cpp	1970-01-01 00:00:00 +0000
+++ src/onedrive/api/clouditem.cpp	2016-09-30 08:26:58 +0000
@@ -0,0 +1,166 @@
+/*
+ * Copyright © 2016 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Gary Wang <[e-mail]>
+ */
+
+#include <onedrive/api/clouditem.h>
+#include <json/json.h>
+
+#include <iostream>
+
+namespace json = Json;
+
+using namespace onedrive::api;
+using namespace std;
+
+extern std::time_t string_to_time(const std::string dt);
+
+class CloudItem::Priv {
+public:
+    Priv(const json::Value &root) {
+        id_ = root["id"].asString();
+        updated_date_ = string_to_time(root["lastModifiedDateTime"].asString());
+        created_date_ = string_to_time(root["createdDateTime"].asString());
+        etag_  = root["eTag"].asString();
+        name_  = root["name"].asString();
+        owner_ = root["createdBy"]["user"]["displayName"].asString();
+        folder_id_ = root["parentReference"]["id"].asString();
+        mimetype_  = root["file"].isMember("mimeType") ? root["file"]["mimeType"].asString() : "";
+        content_size_ = root["size"].asInt64();
+        download_url_ = root["@content.downloadUrl"].asString();
+        folder_path_  = root["parentReference"]["path"].asString();
+
+        if (!mimetype_.empty()) {
+            if (mimetype_.find("video/") != string::npos) {
+                if (root.isMember("photo") && root["photo"].isMember("takenDateTime")) {
+                    metadata_["takenDateTime"] = root["photo"]["takenDateTime"].asString();
+                }
+                metadata_["width"]   = root["video"]["width"].asInt();
+                metadata_["height"]  = root["video"]["height"].asInt();
+                metadata_["bitrate"] = root["video"]["bitrate"].asInt();
+                metadata_["duration"] = root["video"]["duration"].asInt();
+            } else if (mimetype_.find("audio/") != string::npos) {
+                metadata_["duration"] = root["duration"]["duration"].asUInt();
+            } else if (mimetype_.find("image/") != string::npos) {
+                metadata_["width"] = root["image"]["width"].asInt();
+                metadata_["height"] = root["image"]["height"].asInt();
+
+                if (root.isMember("photo")) {
+                    if (root["photo"].isMember("cameraMake"))
+                        metadata_["cameraMake"] = root["photo"]["cameraMake"].asString();
+                    if (root["photo"].isMember("cameraModel"))
+                        metadata_["cameraModel"] = root["photo"]["cameraModel"].asString();
+                    if (root["photo"].isMember("exposureDenominator"))
+                        metadata_["exposureDenominator"] = root["photo"]["exposureDenominator"].asInt();
+                    if (root["photo"].isMember("exposureNumerator"))
+                        metadata_["exposureNumerator"] = root["photo"]["exposureNumerator"].asInt();
+                    if (root["photo"].isMember("fNumber"))
+                        metadata_["fNumber"] = root["photo"]["fNumber"].asFloat();
+                    if (root["photo"].isMember("iso"))
+                        metadata_["iso"] = root["photo"]["iso"].asInt();
+                }
+            }
+        }
+    #ifndef NDEBUG
+        cout << "id: "<< id_ << " name: " << name_ << "  etag: "<< etag_ << endl;
+    #endif
+    }
+
+  std::string id_;
+
+  std::string name_;
+
+  std::time_t created_date_;
+
+  std::time_t updated_date_;
+
+  std::string etag_;
+
+  std::string owner_;
+
+  std::string folder_path_;
+
+  std::string suffix_;
+
+  int64_t     content_size_;
+
+  std::string download_url_;
+
+  std::string mimetype_;
+
+  std::string folder_id_;
+
+  std::unordered_map<std::string, std::string> metadata_;
+};
+
+CloudItem::CloudItem(const json::Value &root)
+    : p(std::make_shared<Priv>(root)){
+}
+
+const string &CloudItem::id() const {
+    return p->id_;
+}
+
+const string &CloudItem::name() const {
+    return  p->name_;
+}
+
+const time_t &CloudItem::created_date() const {
+    return p->created_date_;
+}
+
+const time_t &CloudItem::updated_date() const {
+    return p->updated_date_;
+}
+
+const string &CloudItem::download_url() const {
+    return p->download_url_;
+}
+
+const string &CloudItem::folder_id() const {
+    return p->folder_id_;
+}
+
+const string &CloudItem::etag() const {
+    return p->etag_;
+}
+
+const string &CloudItem::owner() const {
+    return p->owner_;
+}
+
+CloudResource::Property CloudItem::property() const {
+    return CloudResource::Property::Content;
+}
+
+int64_t CloudItem::size() const {
+    return p->content_size_;
+}
+
+const string &CloudItem::folder_path() const
+{
+    return p->folder_path_;
+}
+
+const string &CloudItem::mimetype() const
+{
+    return p->mimetype_;
+}
+
+std::unordered_map<string, string> &CloudItem::metadata() const
+{
+    return p->metadata_;
+}

=== added file 'src/onedrive/api/config.h'
--- src/onedrive/api/config.h	1970-01-01 00:00:00 +0000
+++ src/onedrive/api/config.h	2016-09-30 08:26:58 +0000
@@ -0,0 +1,55 @@
+/*
+ * Copyright (C) 2016 Canonical, Ltd.
+ *
+ * This library is free software; you can redistribute it and/or modify it under
+ * the terms of version 3 of the GNU Lesser General Public License as published
+ * by the Free Software Foundation.
+ *
+ * This library is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
+ * details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Author: Gary Wang <[e-mail]>
+ */
+
+#ifndef ONEDRIVE_API_CONFIG_H_
+#define ONEDRIVE_API_CONFIG_H_
+
+#include <memory>
+#include <string>
+
+namespace onedrive {
+namespace api {
+
+struct Config {
+    typedef std::shared_ptr<Config> Ptr;
+
+    /*
+     * The access token assigned by onedrive after authenticated.
+     */
+    std::string access_token { };
+
+    /*
+     * The root of all API request URLs
+     */
+    std::string apiroot {"https://api.onedrive.com/v1.0"};
+
+    /*
+     * The custom HTTP user agent string for this library
+     */
+    std::string user_agent {"ubuntu-onedrive-lib"};
+
+    /*
+     *  request timeout for onedrive restful api
+     */
+    int request_timeout = 1;
+};
+
+}
+}
+
+#endif /* ONEDRIVE_API_CONFIG_H_ */

=== added file 'src/onedrive/api/downloadtask.cpp'
--- src/onedrive/api/downloadtask.cpp	1970-01-01 00:00:00 +0000
+++ src/onedrive/api/downloadtask.cpp	2016-09-30 08:26:58 +0000
@@ -0,0 +1,65 @@
+/*
+ * Copyright © 2016 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Gary Wang <[e-mail]>
+ */
+
+#include <onedrive/api/downloadtask.h>
+
+#include "downloadtask_priv.h"
+#include "taskhandler.h"
+
+using namespace onedrive::api;
+using namespace std;
+
+DownloadTask::DownloadTask(std::shared_ptr<DownloadTaskPriv> p)
+    :p_(p){
+}
+
+const string & DownloadTask::task_url() const {
+    return p_->task_url();
+}
+
+const string &DownloadTask::error_code() const {
+    return p_->error_code();
+}
+
+Task::Status DownloadTask::status() const {
+    return p_->task_handler()->status();
+}
+
+const string & DownloadTask::content_name() const {
+    return p_->content_name();
+}
+
+const string & DownloadTask::file_path() const {
+    return p_->file_path();
+}
+
+Task::ProgressHandler & DownloadTask::progress_changed() {
+    return p_->progress_changed();
+}
+
+Task::StatusHandler & DownloadTask::status_changed() {
+    return p_->status_changed();
+}
+
+const string & DownloadTask::error_message() const {
+    return p_->error_string();
+}
+
+void DownloadTask::cancel() {
+    p_->task_handler()->cancel();
+}

=== added file 'src/onedrive/api/downloadtask_priv.cpp'
--- src/onedrive/api/downloadtask_priv.cpp	1970-01-01 00:00:00 +0000
+++ src/onedrive/api/downloadtask_priv.cpp	2016-09-30 08:26:58 +0000
@@ -0,0 +1,193 @@
+/*
+ * Copyright © 2016 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Gary Wang <[e-mail]>
+ */
+
+#include "downloadtask_priv.h"
+#include "taskhandler.h"
+
+#include <boost/filesystem.hpp>
+#include <json/json.h>
+
+#include <iostream>
+
+namespace json = Json;
+namespace fs = boost::filesystem;
+
+using namespace onedrive::api;
+using namespace std;
+
+namespace {
+static const std::string public_download_dir = std::string(getenv("HOME")) + "/Downloads";
+}
+
+DownloadTaskPriv::DownloadTaskPriv(const CloudItem::Ptr &root,
+                                   Task::Buffer_Callback write_cb)
+    :progress_handler_(nullptr),
+     status_handler_(nullptr),
+     buffer_callback_(write_cb),
+     task_handler_(std::make_shared<TaskHandler>())
+{
+    content_id_ = root->id();
+    content_name_ = root->name();
+    task_url_ = root->download_url();
+
+    if (!buffer_callback_) {
+        // create temp file path in temp path for writing
+        file_path_ = fs::path(fs::temp_directory_path() / fs::unique_path())
+            .string();
+    }
+
+    task_handler_->on_prepare() = [this](){
+        if (!buffer_callback_) {
+            if (ofs_.is_open())
+                ofs_.close();
+
+            ofs_.open(file_path_, std::ofstream::out | std::ofstream::trunc);
+            if (ofs_.fail()) {
+                throw runtime_error("failed to open file" + file_path_ + "  error: " + strerror(errno));
+            }
+        }
+
+        //change status
+        task_handler_->set_status(Task::Status::Running);
+    };
+
+    task_handler_->on_progress() = [this](float percent){
+        if (progress_handler_) {
+            progress_handler_(percent);
+        }
+    };
+
+    task_handler_->on_status() = [this](Task::Status status){
+        if (status_handler_) {
+            status_handler_(status);
+        }
+    };
+
+    task_handler_->on_finished() = [this](const std::string &/*response*/) -> bool {
+        ofs_.close();
+
+        if (!buffer_callback_) {
+            std::string download_dir;
+            if (getenv("ONEDRIVE_DOWNLOAD_FOLDER")) {
+                download_dir = string(getenv("ONEDRIVE_DOWNLOAD_FOLDER"));
+            } else {
+                download_dir = public_download_dir;
+            }
+
+            if (!fs::exists(fs::path(download_dir))) {
+                try {
+                    fs::create_directory(fs::path(download_dir));
+                } catch(boost::filesystem::filesystem_error& e) {
+                    cerr << "create download directory failed"<< download_dir
+                        <<  "error: " << e.what() << endl;
+                }
+                return false;
+            }
+
+            //check if there is a duplicate one
+            std::string stem = fs::path(content_name_).stem().string();
+            fs::path dest = download_dir + "/" + content_name_;
+            int dup_count = 0;
+            while (fs::exists(dest)) {
+                dest = fs::path(download_dir) / fs::path(stem
+                        + "_"
+                        + std::to_string(++dup_count)
+                        + dest.extension().string());
+            }
+
+            try {
+                // rename in final when download is complete.
+                fs::rename(file_path_, dest);
+                file_path_ = dest.string();
+            } catch (boost::filesystem::filesystem_error& e) {
+                cerr << "create download directory failed"<< download_dir
+                    <<  "error: " << e.what() << endl;
+                return false;
+            }
+        }
+
+        //change status
+        task_handler_->reset_broken_counter();
+        task_handler_->set_status(Task::Status::Complete);
+
+        return true;
+    };
+
+    task_handler_->on_ready_read() = [this](const string &data){
+        if (buffer_callback_) {
+            buffer_callback_((void *)data.c_str(), data.size());
+        } else {
+            ofs_.write(data.c_str(), data.size());
+        }
+    };
+}
+
+const string & DownloadTaskPriv::task_url() const {
+    return task_url_;
+}
+
+Task::Status DownloadTaskPriv::status() const {
+    return task_handler_->status();
+}
+
+const string & DownloadTaskPriv::content_name() const {
+    return content_name_;
+}
+
+const string & DownloadTaskPriv::file_path() const {
+    return file_path_;
+}
+
+const string &DownloadTaskPriv::error_code() const {
+    return error_code_;
+}
+
+Task::ProgressHandler & DownloadTaskPriv::progress_changed() {
+    return progress_handler_;
+}
+
+Task::StatusHandler &DownloadTaskPriv::status_changed() {
+    return status_handler_;
+}
+
+Task::Buffer_Callback &DownloadTaskPriv::buffer_callback() {
+    return buffer_callback_;
+}
+
+const string & DownloadTaskPriv::error_string() const {
+    return error_string_;
+}
+
+void DownloadTaskPriv::set_error_info(const std::string & err) {
+    json::Reader reader;
+    json::Value root;
+    if (reader.parse(err, root)) {
+        error_code_ = root["error"]["code"].asString();
+        error_string_ = root["error"]["message"].asString();
+    } else {
+        error_string_ = err;
+    }
+}
+
+void DownloadTaskPriv::cancel() {
+    task_handler_->cancel();
+}
+
+std::shared_ptr<TaskHandler> DownloadTaskPriv::task_handler() const {
+    return task_handler_;
+}

=== added file 'src/onedrive/api/downloadtask_priv.h'
--- src/onedrive/api/downloadtask_priv.h	1970-01-01 00:00:00 +0000
+++ src/onedrive/api/downloadtask_priv.h	2016-09-30 08:26:58 +0000
@@ -0,0 +1,95 @@
+/*
+ * Copyright © 2016 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Gary Wang <[e-mail]>
+ */
+
+#ifndef ONEDRIVE_API_DOWNLOADTASKPRIV_H_
+#define ONEDRIVE_API_DOWNLOADTASKPRIV_H_
+
+#include <onedrive/api/task.h>
+#include <onedrive/api/clouditem.h>
+
+#include <memory>
+#include <fstream>
+
+namespace onedrive {
+namespace api {
+
+class TaskHandler;
+
+class DownloadTaskPriv {
+public:
+    typedef std::shared_ptr<DownloadTaskPriv>  Ptr;
+
+    DownloadTaskPriv(const CloudItem::Ptr &root,
+                     Task::Buffer_Callback write_cb = nullptr);
+
+    virtual ~DownloadTaskPriv() = default;
+
+    const std::string & task_url() const;
+
+    Task::Status status() const;
+
+    const std::string & content_id() const;
+  
+    const std::string & content_name() const;
+  
+    const std::string & file_path() const;
+
+    const std::string & error_code() const;
+
+    const std::string & error_string() const;
+
+    void set_error_info(const std::string & err);
+  
+    Task::ProgressHandler & progress_changed();
+  
+    Task::StatusHandler & status_changed(); 
+  
+    Task::Buffer_Callback & buffer_callback();
+
+    void cancel(); 
+
+    std::shared_ptr<TaskHandler> task_handler() const;
+  
+private:
+    std::string content_id_;
+
+    std::string content_name_;
+
+    std::string file_path_;
+
+    std::string task_url_;
+
+    std::string error_code_;
+
+    std::string error_string_;
+
+    std::ofstream   ofs_;
+
+    Task::ProgressHandler progress_handler_;
+
+    Task::StatusHandler status_handler_;
+
+    Task::Buffer_Callback buffer_callback_;
+
+    std::shared_ptr<TaskHandler> task_handler_;
+};
+
+}
+}
+
+#endif // ONEDRIVE_API_DOWNLOADTASKPRIV_H_

=== added file 'src/onedrive/api/storageinfo.cpp'
--- src/onedrive/api/storageinfo.cpp	1970-01-01 00:00:00 +0000
+++ src/onedrive/api/storageinfo.cpp	2016-09-30 08:26:58 +0000
@@ -0,0 +1,64 @@
+/*
+ * Copyright © 2016 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Gary Wang <[e-mail]>
+ */
+
+#include <onedrive/api/storageinfo.h>
+
+#include <json/json.h>
+
+using namespace onedrive::api;
+using namespace std;
+
+namespace json = Json;
+
+class StorageInfo::Priv {
+public:
+    Priv(const json::Value &root) {
+        id_   = root["owner"]["user"]["id"].asString();
+        name_ = root["owner"]["user"]["displayName"].asString();
+        disk_size_ = root["quota"]["total"].asUInt64();
+        used_disk_size_ = root["quota"]["used"].asUInt64();
+    }
+
+    string id_;
+
+    string name_;
+
+    int64_t used_disk_size_;
+
+    int64_t disk_size_;
+};
+
+StorageInfo::StorageInfo(const json::Value &root)
+    : p(std::make_shared<Priv>(root)){
+}
+
+int64_t StorageInfo::used_disk_size() const {
+    return p->used_disk_size_;
+}
+
+int64_t StorageInfo::total_disk_size() const {
+    return p->disk_size_;
+}
+
+const string & StorageInfo::id() const {
+    return p->id_;
+}
+
+const string & StorageInfo::name() const {
+    return p->name_;
+}

=== added file 'src/onedrive/api/syncmanager.cpp'
--- src/onedrive/api/syncmanager.cpp	1970-01-01 00:00:00 +0000
+++ src/onedrive/api/syncmanager.cpp	2016-09-30 08:26:58 +0000
@@ -0,0 +1,70 @@
+/*
+ * Copyright © 2016 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Gary Wang <[e-mail]>
+ */
+
+
+#include <onedrive/api/syncmanager.h>
+#include <onedrive/api/taskqueue.h>
+
+#include "syncthread.h"
+#include "client_priv.h"
+#include "syncmanager_priv.h"
+
+#include <iostream>
+
+using namespace onedrive::api;
+using namespace std;
+
+SyncManager::SyncManager(ClientPriv* client_priv)
+    :p_(std::make_shared<SyncManagerPriv>(client_priv)) {
+}
+
+void SyncManager::start() {
+    p_->start();
+}
+
+void SyncManager::cancel() {
+    p_->cancel();
+}
+
+void SyncManager::pause() {
+    p_->pause();
+}
+
+UploadTask::Ptr SyncManager::add_upload_task(const UploadRequest &request_item) {
+    return p_->add_upload_task(request_item);
+}
+
+UploadTask::Ptr SyncManager::add_upload_task(const UploadBufferCb &buffer_cb) {
+    return p_->add_upload_task(buffer_cb);
+}
+
+DownloadTask::Ptr SyncManager::add_download_task(const string &content_id) {
+    return p_->add_download_task(content_id);
+}
+
+DownloadTask::Ptr SyncManager::add_download_task(const DownloadBufferCb &buffer_cb) {
+    return p_->add_download_task(buffer_cb);
+}
+
+TaskQueue<std::shared_ptr<DownloadTask>> SyncManager::download_queue() {
+    return p_->download_queue();
+}
+
+TaskQueue<std::shared_ptr<UploadTask>> SyncManager::upload_queue() {
+    return p_->upload_queue();
+}

=== added file 'src/onedrive/api/syncmanager_priv.cpp'
--- src/onedrive/api/syncmanager_priv.cpp	1970-01-01 00:00:00 +0000
+++ src/onedrive/api/syncmanager_priv.cpp	2016-09-30 08:26:58 +0000
@@ -0,0 +1,111 @@
+/*
+ * Copyright © 2016 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Gary Wang <[e-mail]>
+ */
+
+#include <onedrive/api/syncmanager.h>
+#include <onedrive/api/taskqueue.h>
+
+#include "syncmanager_priv.h"
+#include "client_priv.h"
+#include "syncthread.h"
+
+#include <iostream>
+
+using namespace onedrive::api;
+using namespace std;
+
+SyncManagerPriv::SyncManagerPriv(ClientPriv *client)
+    : download_thread_()
+    , upload_thread_()
+    , client_(client){
+    start();
+}
+
+SyncManagerPriv::~SyncManagerPriv() {
+    download_thread_.stop();
+    upload_thread_.stop();
+}
+
+void SyncManagerPriv::set_access_token(const std::string &token) {
+    download_thread_.set_access_token(token);
+    upload_thread_.set_access_token(token);
+}
+
+DownloadTask::Ptr SyncManagerPriv::add_download_task(const string &content_id) {
+    auto res = client_->metadata(content_id);
+    auto item = std::static_pointer_cast<CloudItem>(res);
+    auto task_p = std::shared_ptr<DownloadTaskPriv>(new DownloadTaskPriv(item));
+    download_thread_.add_task(task_p);
+
+    auto task = std::shared_ptr<DownloadTask>(new DownloadTask(task_p));
+    download_queue_.push(task);
+    return task;
+}
+
+DownloadTask::Ptr SyncManagerPriv::add_download_task(const DownloadBufferCb &buf_item) {
+    auto res = client_->metadata(buf_item.content_id);
+    auto item = std::static_pointer_cast<CloudItem>(res);
+    auto task_p = std::shared_ptr<DownloadTaskPriv>(new DownloadTaskPriv(item, buf_item.write_cb));
+    download_thread_.add_task(task_p);
+
+    auto task = std::shared_ptr<DownloadTask>(new DownloadTask(task_p));
+    download_queue_.push(task);
+    return task;
+}
+
+UploadTask::Ptr SyncManagerPriv::add_upload_task(const UploadRequest &request) {
+    auto item_p = std::shared_ptr<UploadTaskPriv>(new UploadTaskPriv(request));
+    cout << "push upload link url in queue : " + item_p->task_url() << endl;
+    upload_thread_.add_task(item_p);
+
+    auto item = std::shared_ptr<UploadTask>(new UploadTask(item_p));
+    upload_queue_.push(item);
+    return item;
+}
+
+UploadTask::Ptr SyncManagerPriv::add_upload_task(const UploadBufferCb &buffer_cb) {
+    auto item_p = std::shared_ptr<UploadTaskPriv>(new UploadTaskPriv(buffer_cb));
+    cout << "push upload link url in queue : " + item_p->task_url() << endl;
+    upload_thread_.add_task(item_p);
+
+    auto item =  std::shared_ptr<UploadTask>(new UploadTask(item_p));
+    upload_queue_.push(item);
+    return item;
+}
+
+TaskQueue<DownloadTask::Ptr> SyncManagerPriv::download_queue() {
+    return download_queue_;
+}
+
+TaskQueue<UploadTask::Ptr> SyncManagerPriv::upload_queue() {
+    return upload_queue_;
+}
+
+void SyncManagerPriv::start() {
+    download_thread_.start();
+    upload_thread_.start();
+}
+
+void SyncManagerPriv::cancel() {
+    download_thread_.cancel();
+    upload_thread_.cancel();
+}
+
+void SyncManagerPriv::pause() {
+    download_thread_.pause();
+    upload_thread_.pause();
+}

=== added file 'src/onedrive/api/syncmanager_priv.h'
--- src/onedrive/api/syncmanager_priv.h	1970-01-01 00:00:00 +0000
+++ src/onedrive/api/syncmanager_priv.h	2016-09-30 08:26:58 +0000
@@ -0,0 +1,76 @@
+/*
+ * Copyright © 2016 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Gary Wang <[e-mail]>
+ */
+
+#ifndef ONEDRIVE_API_SYNCMANAGERPRIV_H_
+#define ONEDRIVE_API_SYNCMANAGERPRIV_H_
+
+#include <onedrive/api/taskqueue.h>
+#include <onedrive/api/downloadtask.h>
+#include <onedrive/api/uploadtask.h>
+#include <onedrive/api/visibility.h>
+
+#include "syncthread.h"
+
+#include <memory>
+
+namespace onedrive {
+namespace api {
+
+class ClientPriv;
+
+class SyncManagerPriv {
+public:
+    SyncManagerPriv(ClientPriv *client);
+
+    ~SyncManagerPriv();
+
+    void set_access_token(const std::string &token);
+
+    DownloadTask::Ptr add_download_task(const std::string &content_id);
+
+    DownloadTask::Ptr add_download_task(const DownloadBufferCb &buf_item);
+
+    UploadTask::Ptr add_upload_task(const UploadRequest &request);
+
+    UploadTask::Ptr add_upload_task(const UploadBufferCb &buffer_cb);
+
+    TaskQueue<DownloadTask::Ptr>  download_queue();
+
+    TaskQueue<UploadTask::Ptr>    upload_queue();
+
+    void start();
+
+    void cancel();
+
+    void pause();
+
+private:
+    SyncThread<DownloadTaskPriv>   download_thread_;
+    SyncThread<UploadTaskPriv>     upload_thread_;
+
+    TaskQueue<DownloadTask::Ptr> download_queue_;
+    TaskQueue<UploadTask::Ptr>   upload_queue_;
+
+    ClientPriv*     client_;
+};
+
+
+}
+}
+
+#endif // ONEDRIVE_API_SYNCMANAGERPRIV_H_

=== added file 'src/onedrive/api/syncthread.cpp'
--- src/onedrive/api/syncthread.cpp	1970-01-01 00:00:00 +0000
+++ src/onedrive/api/syncthread.cpp	2016-09-30 08:26:58 +0000
@@ -0,0 +1,447 @@
+/*
+ * Copyright © 2016 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Gary Wang <[e-mail]>
+ */
+
+#include "syncthread.h"
+#include "taskhandler.h"
+#include "uploadtask_priv.h"
+#include "downloadtask_priv.h"
+
+#include <boost/algorithm/string.hpp>
+#include <core/net/http/streaming_client.h>
+#include <core/net/http/streaming_request.h>
+#include <core/net/http/response.h>
+#include <core/net/http/status.h>
+
+#include <fstream>
+#include <future>
+#include <iostream>
+
+namespace http = core::net::http;
+namespace net = core::net;
+
+using namespace onedrive::api;
+using namespace std;
+
+template <typename T>
+class SyncThread<T>::HttpStreamClient {
+public:
+    HttpStreamClient(int request_timeout) :
+        request_timeout_(request_timeout),
+        client_(http::make_streaming_client()),
+        worker_ { [this]() {client_->run();} }{
+    }
+
+    ~HttpStreamClient() {
+        client_->stop();
+        if (worker_.joinable()) {
+            worker_.join();
+        }
+    }
+
+    void async_get(shared_ptr<T> ptr,
+                   const http::Header &headers) {
+        auto prom = make_shared<promise<bool>>();
+
+        auto task_handler = ptr->task_handler();
+        http::Request::Handler handler;
+        handler.on_progress([task_handler](const http::Request::Progress& progress)
+            {
+                if (task_handler->status() == Task::Status::Canceled) {
+                    return http::Request::Progress::Next::abort_operation;
+                }
+
+                if (progress.download.current > 0.0 &&  progress.download.total > 0.0) {
+                    double percent = progress.download.current / progress.download.total;
+                    task_handler->on_progress()(percent);
+                }
+
+                return http::Request::Progress::Next::continue_operation;
+            }
+        );
+        handler.on_error([prom](const net::Error& e)
+            {
+                prom->set_exception(make_exception_ptr(runtime_error(e.what())));
+        });
+        handler.on_response([prom, task_handler](const http::Response& response)
+            {
+                if (response.status != http::Status::ok) {
+                    prom->set_exception(make_exception_ptr(runtime_error(response.body)));
+                } else {
+                    prom->set_value(task_handler->on_finished()(response.body));
+                }
+            }
+        );
+
+        auto http_config = http::Request::Configuration::from_uri_as_string(
+                    ptr->task_url());
+        http_config.header = headers;        
+
+        std::shared_future<bool> future = prom->get_future();
+        auto request = client_->streaming_get(http_config);
+        request->abort_request_if(low_speed_limit, std::chrono::seconds{low_speed_time});
+        request->set_timeout(std::chrono::milliseconds{request_timeout_});
+        request->async_execute(handler, task_handler->on_ready_read());
+
+        task_handler->attach_request(request, future);
+    }
+
+    void async_put(shared_ptr<T> ptr,
+                    const http::Header &headers,
+                    std::istream &payload,
+                    std::size_t size) {
+        auto prom = make_shared<promise<bool>>();
+
+        auto task_handler = ptr->task_handler();
+        http::Request::Handler handler;
+        handler.on_progress([task_handler](const http::Request::Progress& progress)
+            {
+                if (task_handler->status() == Task::Status::Canceled) {
+                    return http::Request::Progress::Next::abort_operation;
+                }
+
+                if (progress.upload.current > 0.0 &&  progress.upload.total > 0.0) {
+                    double percent = (progress.upload.current / progress.upload.total);
+                    task_handler->on_progress()(percent);
+                }
+
+                return http::Request::Progress::Next::continue_operation;
+            }
+        );
+        handler.on_error([prom](const net::Error& e)
+            {
+                prom->set_exception(make_exception_ptr(runtime_error(e.what())));
+        });
+        handler.on_response([prom, task_handler](const http::Response& response)
+            {
+                if (response.status != http::Status::ok &&
+                        response.status != http::Status::created) {
+                    prom->set_exception(make_exception_ptr(runtime_error(response.body)));
+                } else {
+                    prom->set_value(task_handler->on_finished()(response.body));
+                }
+            }
+        );
+
+        auto http_config = http::Request::Configuration::from_uri_as_string(
+                    ptr->task_url());
+        http_config.header = headers;
+
+        std::shared_future<bool> future = prom->get_future();
+        auto request = client_->streaming_put(http_config, payload, size);
+        request->abort_request_if(low_speed_limit, std::chrono::seconds{low_speed_time});
+        request->set_timeout(std::chrono::milliseconds{request_timeout_});
+        request->async_execute(handler, task_handler->on_ready_read());
+
+        task_handler->attach_request(request, future);
+    }
+
+    void async_put(shared_ptr<T> ptr,
+                    const http::Header &headers,
+                    std::function<size_t(void *dest, size_t buf_size)> read_cb,
+                    std::size_t size) {
+        auto prom = make_shared<promise<bool>>();
+
+        auto task_handler = ptr->task_handler();
+        http::Request::Handler handler;
+        handler.on_progress([task_handler](const http::Request::Progress& progress)
+            {
+                if (task_handler->status() == Task::Status::Canceled) {
+                    return http::Request::Progress::Next::abort_operation;
+                }
+
+                if (progress.upload.current > 0.0 &&  progress.upload.total > 0.0) {
+                    double percent = (progress.upload.current / progress.upload.total);
+                    task_handler->on_progress()(percent);
+                }
+
+                return http::Request::Progress::Next::continue_operation;
+            }
+        );
+        handler.on_error([prom](const net::Error& e)
+            {
+                prom->set_exception(make_exception_ptr(runtime_error(e.what())));
+        });
+        handler.on_response([prom, task_handler](const http::Response& response)
+            {
+                if (response.status != http::Status::ok &&
+                        response.status != http::Status::created) {
+                    prom->set_exception(make_exception_ptr(runtime_error(response.body)));
+                } else {
+                    prom->set_value(task_handler->on_finished()(response.body));
+                }
+            }
+        );
+
+        auto http_config = http::Request::Configuration::from_uri_as_string(
+                    ptr->task_url());
+        http_config.header = headers;
+
+        std::shared_future<bool> future = prom->get_future();
+        auto request = client_->streaming_put(http_config, read_cb, size);
+        request->abort_request_if(low_speed_limit, std::chrono::seconds{low_speed_time});
+        request->set_timeout(std::chrono::milliseconds{request_timeout_});
+        request->async_execute(handler, task_handler->on_ready_read());
+
+        task_handler->attach_request(request, future);
+    }
+
+    const int low_speed_limit = 1;
+
+    const chrono::seconds low_speed_time{chrono::seconds{10}};
+
+    int request_timeout_;
+
+    std::shared_ptr<core::net::http::StreamingClient> client_;
+
+    std::thread worker_;
+};
+
+template<typename T>
+SyncThread<T>::SyncThread()
+    : client_(std::make_shared<SyncThread::HttpStreamClient>(sync_timeout_ * 500)),
+      stop_(true){
+}
+
+template <typename T>
+SyncThread<T>::~SyncThread() {
+    stop();
+}
+
+template <typename T>
+void SyncThread<T>::start() {
+    pause_ = false;
+
+    if (stop_ == true) {
+        stop_ = false;
+        thread_ = std::thread(&SyncThread::run, this);
+    } else {
+        //if it's running, then resume
+        for (auto & item_ptr : task_queue_) {
+            if (item_ptr->status() == Task::Status::Paused) {
+                item_ptr->task_handler()->resume();
+            }
+        }
+    }
+}
+
+template <typename T>
+void SyncThread<T>::cancel() {
+    stop();
+}
+
+template <typename T>
+void SyncThread<T>::pause() {
+    std::unique_lock<std::mutex> lock(mutex_);
+
+    //pause task if it's running
+    for (auto & item_ptr : task_queue_) {
+        if (item_ptr->status() == Task::Status::Running) {
+            item_ptr->task_handler()->pause();
+        }
+    }
+
+    pause_ = true;
+}
+
+template <typename T>
+void SyncThread<T>::stop() {
+    //cancel task if it's running or prepared in the queue.
+    for (auto & item_ptr : task_queue_) {
+        if (item_ptr->status() == Task::Status::Running
+                || item_ptr->status() == Task::Status::Paused
+                || item_ptr->status() == Task::Status::Unstart) {
+            item_ptr->task_handler()->cancel();
+        }
+    }
+
+    {
+        std::unique_lock<std::mutex> lock(mutex_);
+        if (stop_)
+            return;
+
+        //terminate thread
+        stop_ = true;
+        con_.notify_all();
+    }
+
+    if (thread_.joinable())
+        thread_.join();
+}
+
+template <typename T>
+void SyncThread<T>::set_access_token(const std::string &token) {
+    access_token_ = token;
+}
+
+template <typename T>
+void SyncThread<T>::add_task(std::shared_ptr<T> task_ptr) {
+    task_queue_.push(task_ptr);
+}
+
+template <typename T>
+void SyncThread<T>::run() {
+    std::unique_lock<std::mutex> lock(mutex_);
+
+    std::future_status status = std::future_status::ready;
+    std::shared_ptr<DownloadTaskPriv> task_ptr = nullptr;
+
+    while(!stop_) {
+        con_.wait_for(lock, std::chrono::seconds(sync_timeout_));
+        if (!stop_ && !pause_) {
+            if (status == std::future_status::ready) {
+                //check if there is unstared task item in task queue
+                typename TaskQueue<std::shared_ptr<T>>::const_iterator it = std::find_if(
+                            task_queue_.begin(),
+                            task_queue_.end(),
+                            [](std::shared_ptr<T> task){
+                    return (task->status() == Task::Status::Unstart);
+                });
+
+                if (it == task_queue_.end())
+                    continue;
+
+                http::Header header;
+                header.add("Authorization", "bearer " + access_token_);
+                task_ptr = (*it);
+                try {
+                    task_ptr->task_handler()->on_prepare()();
+                } catch (std::runtime_error e) {
+                    cerr << "error: " << e.what() << endl;
+                    continue;
+                }
+                client_->async_get(task_ptr, header);
+            }
+
+            if (task_ptr) {
+                auto task_handler = task_ptr->task_handler();
+                //do not wait block here forever until download is finished,
+                //that gives a chance to pause/resume download from sync thread.
+                status = task_handler->wait_for(std::chrono::seconds(sync_timeout_));
+                try {
+                    if (status == std::future_status::ready &&
+                        task_handler->get_result()) {
+                        cout << "download content successfully:" <<
+                                task_ptr->file_path() << endl;
+                        task_handler->detach_request();
+                        task_ptr.reset();
+                    }
+                } catch(std::runtime_error &e) {
+                    // if error is caused by net issue,not manually(application callback)
+                    // increase broken counter and try it again. Once broken counter exceeds broken limit,
+                    // it's regarded as the "broken" one and drop it
+                    if (task_handler->status() != Task::Status::Canceled) {
+                        if (!task_handler->is_broken()) {
+                            task_handler->add_broken_counter();
+                            task_handler->set_status(Task::Status::Unstart);
+                        } else {
+                            task_ptr->set_error_info(e.what());
+                            task_handler->set_status(Task::Status::Broken);
+                        }
+                    }
+
+                    cerr << "download content: "<< task_ptr->content_name()
+                         <<  " error: " << e.what() << endl;
+                    task_ptr.reset();
+                }
+            }
+        }
+    }
+}
+
+namespace onedrive {
+namespace api {
+
+template <>
+void SyncThread<UploadTaskPriv>::run() {
+    std::unique_lock<std::mutex> lock(mutex_);
+
+    std::future_status status = std::future_status::ready;
+    UploadTaskPriv::Ptr task_ptr = nullptr;
+    while(!stop_) {
+        con_.wait_for(lock, std::chrono::seconds(sync_timeout_));
+
+        if (!stop_ && !pause_) {
+            if (status == std::future_status::ready) {
+                //check if there is unstared task item in task queue
+                typename TaskQueue<UploadTaskPriv::Ptr>::const_iterator it = std::find_if(
+                            task_queue_.begin(),
+                            task_queue_.end(),
+                            [](UploadTaskPriv::Ptr task){
+                    return (task->status() == Task::Status::Unstart);
+                });
+
+                if (it == task_queue_.end())
+                    continue;
+
+                http::Header header;
+                header.add("Authorization", "bearer " + access_token_);
+                task_ptr = (*it);
+                task_ptr->task_handler()->on_prepare()();
+                if (task_ptr->buffer_callback()) {
+                    client_->async_put(task_ptr, header, task_ptr->buffer_callback(), task_ptr->file_size());
+                } else {
+                    client_->async_put(task_ptr, header, task_ptr->ifstream(), task_ptr->file_size());
+                }
+            }
+
+            if (task_ptr) {
+                auto task_handler = task_ptr->task_handler();
+                //do not wait block here forever until upload is finished,
+                //that gives a chance to pause/resume upload from sync thread.
+                status = task_handler->wait_for(std::chrono::seconds(sync_timeout_));
+                try {
+                    if (status == std::future_status::ready &&
+                        task_handler->get_result()) {
+                        cout << "upload content successfully:" << task_ptr->content_name() << endl;
+                        task_handler->detach_request();
+                        task_ptr.reset();
+                    }
+                }catch (std::runtime_error &e) {
+                    //if content data is fetched chunk by chunk(buffering), set it broken once failed
+                    //as we didn't cache buffer locally.
+                    if (task_ptr->buffer_callback()) {
+                        task_ptr->set_error_info(e.what());
+                        task_handler->set_status(Task::Status::Broken);
+                    } else if (task_handler->status() != Task::Status::Canceled) {
+                        // if content data is local file, when error is caused by net issue,
+                        //increase broken counter and try it again. Once broken counter exceeds broken limit,
+                        //it's regarded as the "broken" one and we drop it.
+
+                        if (!task_handler->is_broken()) {
+                            task_handler->add_broken_counter();
+                            task_handler->set_status(Task::Status::Unstart);
+                        } else {
+                            task_ptr->set_error_info(e.what());
+                            task_handler->set_status(Task::Status::Broken);
+                        }
+                    }
+
+                    cerr << "upload content: "<< task_ptr->content_name()
+                            <<  " error: " << e.what() << endl;
+                    task_ptr.reset();
+                }
+            }
+        }
+    }
+}
+
+}
+}
+
+template class SyncThread<DownloadTaskPriv>;
+template class SyncThread<UploadTaskPriv>;

=== added file 'src/onedrive/api/syncthread.h'
--- src/onedrive/api/syncthread.h	1970-01-01 00:00:00 +0000
+++ src/onedrive/api/syncthread.h	2016-09-30 08:26:58 +0000
@@ -0,0 +1,81 @@
+/*
+ * Copyright (C) 2016 Canonical, Ltd.
+ *
+ * This library is free software; you can redistribute it and/or modify it under
+ * the terms of version 3 of the GNU Lesser General Public License as published
+ * by the Free Software Foundation.
+ *
+ * This library is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
+ * details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Author: Gary Wang  <[e-mail]>
+ */
+
+#ifndef ONEDRIVE_API_SYNCTHREAD_H_
+#define ONEDRIVE_API_SYNCTHREAD_H_
+
+#include <onedrive/api/taskqueue.h>
+#include <onedrive/api/visibility.h>