Moved everything but iDevice and LockdownClient to pxi files.

Added MobileBackupClient and PropertyListService.

1 files changed, 11 insertions, 192 deletions

diff --git a/cython/imobiledevice.pyx b/cython/imobiledevice.pyx
index befd586..bbec7b8 100644
--- a/cython/imobiledevice.pyx
+++ b/cython/imobiledevice.pyx
@@ -1,24 +1,4 @@
-cdef extern from *:
-    ctypedef unsigned char uint8_t
-    ctypedef short int int16_t
-    ctypedef unsigned short int uint16_t
-    ctypedef unsigned int uint32_t
-    ctypedef int int32_t
-IF UNAME_MACHINE == 'x86_64':
-    ctypedef unsigned long int uint64_t
-ELSE:
-    ctypedef unsigned long long int uint64_t
-
-cimport plist
-
-cdef extern from "pyerrors.h":
-    ctypedef class __builtin__.Exception [object PyBaseExceptionObject]:
-        pass
-
 cdef class BaseError(Exception):
-    cdef dict _lookup_table
-    cdef int16_t _c_errcode
-
     def __cinit__(self, int16_t errcode):
         self._c_errcode = errcode
 
@@ -40,10 +20,6 @@ cdef class BaseError(Exception):
         return self.__str__()
 
 cdef extern from "libimobiledevice/libimobiledevice.h":
-    cdef struct idevice_int:
-        pass
-    ctypedef idevice_int* idevice_t
-    ctypedef int16_t idevice_error_t
     int16_t IDEVICE_E_SUCCESS
     int16_t IDEVICE_E_INVALID_ARG
     int16_t IDEVICE_E_UNKNOWN_ERROR
@@ -51,14 +27,6 @@ cdef extern from "libimobiledevice/libimobiledevice.h":
     int16_t IDEVICE_E_NOT_ENOUGH_DATA
     int16_t IDEVICE_E_BAD_HEADER
     int16_t IDEVICE_E_SSL_ERROR
-    cdef enum idevice_event_type:
-        IDEVICE_DEVICE_ADD = 1,
-        IDEVICE_DEVICE_REMOVE
-    ctypedef struct idevice_event_t:
-        idevice_event_type event
-        char *uuid
-        int conn_type
-    ctypedef idevice_event_t* const_idevice_event_t "const idevice_event_t*"
     ctypedef void (*idevice_event_cb_t) (const_idevice_event_t event, void *user_data)
     cdef extern idevice_error_t idevice_event_subscribe(idevice_event_cb_t callback, void *user_data)
     cdef extern idevice_error_t idevice_event_unsubscribe()
@@ -83,26 +51,25 @@ cdef class iDeviceError(BaseError):
         }
         BaseError.__init__(self, *args, **kwargs)
 
-def set_debug_level(level):
+cpdef set_debug_level(int level):
     idevice_set_debug_level(level)
 
-cdef class iDeviceEvent:
-    cdef const_idevice_event_t _c_event
+cdef class iDeviceEvent: pass
 
 cdef void idevice_event_cb(const_idevice_event_t c_event, void *user_data):
     cdef iDeviceEvent event = iDeviceEvent()
     event._c_event = c_event
     (<object>user_data)(event)
 
-def event_subscribe(callback):
+cpdef event_subscribe(object callback):
     cdef iDeviceError err = iDeviceError(idevice_event_subscribe(idevice_event_cb, <void*>callback))
     if err: raise err
 
-def event_unsubscribe():
+cpdef event_unsubscribe():
     cdef iDeviceError err = iDeviceError(idevice_event_unsubscribe())
     if err: raise err
 
-def get_device_list():
+cpdef get_device_list():
     cdef char** devices
     cdef int count
     cdef list result
@@ -118,8 +85,6 @@ def get_device_list():
     return result
 
 cdef class iDevice:
-    cdef idevice_t _c_dev
-
     def __cinit__(self, uuid=None, *args, **kwargs):
         cdef char* c_uuid = NULL
         if uuid is not None:
@@ -202,8 +167,6 @@ cdef class LockdownError(BaseError):
         BaseError.__init__(self, *args, **kwargs)
 
 cdef class LockdownClient:
-    cdef lockdownd_client_t _c_client
-
     def __cinit__(self, iDevice device not None, char *label=NULL, *args, **kwargs):
         cdef iDevice dev = device
         err = LockdownError(lockdownd_client_new_with_handshake(dev._c_dev, &(self._c_client), label))
@@ -220,155 +183,11 @@ cdef class LockdownClient:
         if err: raise err
         return port
     
-    def goodbye(self):
+    cpdef goodbye(self):
         pass
-        
-
-cdef extern from "libimobiledevice/mobilesync.h":
-    cdef struct mobilesync_client_int:
-        pass
-    ctypedef mobilesync_client_int *mobilesync_client_t
-
-    ctypedef int16_t mobilesync_error_t
-    int16_t MOBILESYNC_E_SUCCESS
-    int16_t MOBILESYNC_E_INVALID_ARG
-    int16_t MOBILESYNC_E_PLIST_ERROR
-    int16_t MOBILESYNC_E_MUX_ERROR
-    int16_t MOBILESYNC_E_BAD_VERSION
-    int16_t MOBILESYNC_E_UNKNOWN_ERROR
-
-    mobilesync_error_t mobilesync_client_new(idevice_t device, uint16_t port, mobilesync_client_t * client)
-    mobilesync_error_t mobilesync_client_free(mobilesync_client_t client)
-    mobilesync_error_t mobilesync_receive(mobilesync_client_t client, plist.plist_t *plist)
-    mobilesync_error_t mobilesync_send(mobilesync_client_t client, plist.plist_t plist)
-
-cdef class MobileSyncError(BaseError):
-    def __init__(self, *args, **kwargs):
-        self._lookup_table = {
-            MOBILESYNC_E_SUCCESS: "Success",
-            MOBILESYNC_E_INVALID_ARG: "Invalid argument",
-            MOBILESYNC_E_PLIST_ERROR: "PList Error",
-            MOBILESYNC_E_MUX_ERROR: "MUX Error",
-            MOBILESYNC_E_BAD_VERSION: "Bad Version",
-            MOBILESYNC_E_UNKNOWN_ERROR: "Unknown error"
-        }
-        BaseError.__init__(self, *args, **kwargs)
-
-cdef class MobileSyncClient:
-    cdef mobilesync_client_t _c_client
-
-    def __cinit__(self, iDevice device not None, LockdownClient lockdown=None, *args, **kwargs):
-        cdef iDevice dev = device
-        cdef LockdownClient lckd
-        if lockdown is None:
-            lckd = LockdownClient(dev)
-        else:
-            lcdk = lockdown
-        port = lckd.start_service("com.apple.mobilesync")
-        err = MobileSyncError(mobilesync_client_new(dev._c_dev, port, &(self._c_client)))
-        if err: raise err
-    
-    def __dealloc__(self):
-        if self._c_client is not NULL:
-            err = MobileSyncError(mobilesync_client_free(self._c_client))
-            if err: raise err
-    
-    cpdef send(self, object obj):
-        cdef plist.Node node
-        cdef plist.plist_t c_node
-        if isinstance(obj, plist.Node):
-            node = obj
-            c_node = node._c_node
-        else:
-            c_node = plist.native_to_plist_t(obj)
-        err = MobileSyncError(mobilesync_send(self._c_client, c_node))
-        if err: raise err
-
-    cpdef receive(self):
-        cdef plist.plist_t c_node = NULL
-        err = MobileSyncError(mobilesync_receive(self._c_client, &(c_node)))
-        if err: raise err
 
-        return plist.plist_t_to_node(c_node)
-
-cdef extern from *:
-    ctypedef char* const_char_ptr "const char*"
-
-cdef extern from "libimobiledevice/notification_proxy.h":
-    cdef struct np_client_int:
-        pass
-    ctypedef np_client_int *np_client_t
-    ctypedef int16_t np_error_t
-    ctypedef void (*np_notify_cb_t) (const_char_ptr notification, void *userdata)
-    np_error_t np_client_new(idevice_t device, uint16_t port, np_client_t *client)
-    np_error_t np_client_free(np_client_t client)
-    np_error_t np_post_notification(np_client_t client, char *notification)
-    np_error_t np_observe_notification(np_client_t client, char *notification)
-    np_error_t np_observe_notifications(np_client_t client, char **notification_spec)
-    np_error_t np_set_notify_callback(np_client_t client, np_notify_cb_t notify_cb, void *userdata)
-
-cdef void np_notify_cb(const_char_ptr notification, void *py_callback):
-    (<object>py_callback)(notification)
-
-cdef class NotificationProxyError(BaseError):
-    pass
-
-cdef class NotificationProxy:
-    cdef np_client_t _c_client
-
-    def __cinit__(self, iDevice device not None, LockdownClient lockdown=None, *args, **kwargs):
-        cdef iDevice dev = device
-        cdef LockdownClient lckd
-        if lockdown is None:
-            lckd = LockdownClient(dev)
-        else:
-            lckd = lockdown
-        port = lckd.start_service("com.apple.mobile.notification_proxy")
-        err = NotificationProxyError(np_client_new(dev._c_dev, port, &(self._c_client)))
-        if err: raise err
-
-    def __dealloc__(self):
-        if self._c_client is not NULL:
-            err = NotificationProxyError(np_client_free(self._c_client))
-            if err: raise err
-    
-    def set_notify_callback(self, callback):
-        err = NotificationProxyError(np_set_notify_callback(self._c_client, np_notify_cb, <void*>callback))
-        if err: raise err
-    
-    def observe_notification(self, notification):
-        err = NotificationProxyError(np_observe_notification(self._c_client, notification))
-        if err: raise err
-
-cdef extern from "libimobiledevice/sbservices.h":
-    cdef struct sbservices_client_int:
-        pass
-    ctypedef sbservices_client_int *sbservices_client_t
-    ctypedef int16_t sbservices_error_t
-    sbservices_error_t sbservices_client_new(idevice_t device, uint16_t port, sbservices_client_t *client)
-    sbservices_error_t sbservices_client_free(sbservices_client_t client)
-    sbservices_error_t sbservices_get_icon_state(sbservices_client_t client, plist.plist_t *state)
-    sbservices_error_t sbservices_set_icon_state(sbservices_client_t client, plist.plist_t newstate)
-    sbservices_error_t sbservices_get_icon_pngdata(sbservices_client_t client, char *bundleId, char **pngdata, uint64_t *pngsize)
-
-cdef class SpringboardServicesError(BaseError):
-    pass
-
-cdef class SpringboardServices:
-    cdef sbservices_client_t _c_client
-
-    def __cinit__(self, iDevice device not None, LockdownClient lockdown=None, *args, **kwargs):
-        cdef iDevice dev = device
-        cdef LockdownClient lckd
-        if lockdown is None:
-            lckd = LockdownClient(dev)
-        else:
-            lckd = lockdown
-        port = lockdown.start_service("com.apple.springboardservices")
-        err = SpringboardServicesError(sbservices_client_new(dev._c_dev, port, &(self._c_client)))
-        if err: raise err
-    
-    def __dealloc__(self):
-        if self._c_client is not NULL:
-            err = SpringboardServicesError(sbservices_client_free(self._c_client))
-            if err: raise err
+include "property_list_service.pxi"
+include "mobilesync.pxi"
+include "notification_proxy.pxi"
+include "sbservices.pxi"
+include "mobilebackup.pxi"