reverted changes in callbacks, needs to be redone

Author: babca

gsmmodem/modem.py

@@ -146,11 +146,11 @@ class GsmModem(SerialComms):
     CDSI_REGEX = re.compile('\+CDSI:\s*"([^"]+)",(\d+)$')
     CDS_REGEX  = re.compile('\+CDS:\s*([0-9]+)"$')
 
-    def __init__(self, port, baudrate=115200, incomingCallCallbackFunc=None, smsReceivedCallbackFunc=None, smsStatusReportCallbackFunc=None, requestDelivery=True, AT_CNMI="", *a, **kw):
+    def __init__(self, port, baudrate=115200, incomingCallCallbackFunc=None, smsReceivedCallbackFunc=None, smsStatusReportCallback=None, requestDelivery=True, AT_CNMI="", *a, **kw):
         super(GsmModem, self).__init__(port, baudrate, notifyCallbackFunc=self._handleModemNotification, *a, **kw)
-        self.incomingCallCallbackFunc = incomingCallCallbackFunc
-        self.smsReceivedCallbackFunc = smsReceivedCallbackFunc
-        self.smsStatusReportCallbackFunc = smsStatusReportCallbackFunc
+        self.incomingCallCallback = incomingCallCallbackFunc or self._placeholderCallback
+        self.smsReceivedCallback = smsReceivedCallbackFunc or self._placeholderCallback
+        self.smsStatusReportCallback = smsStatusReportCallback or self._placeholderCallback
         self.requestDelivery = requestDelivery
         self.AT_CNMI = AT_CNMI or "2,1,0,2"
         # Flag indicating whether caller ID for incoming call notification has been set up
@@ -377,7 +377,7 @@ def connect(self, pin=None, waitingForModemToStartInSeconds=0):
             del cpmsSupport
             del cpmsLine
 
-        if self._smsReadSupported and (self.smsReceivedCallbackFunc or self.smsStatusReportCallbackFunc):
+        if self._smsReadSupported and (self.smsReceivedCallback or self.smsStatusReportCallback):
             try:
                 self.write('AT+CNMI=' + self.AT_CNMI)  # Set message notifications
             except CommandError:
@@ -1067,16 +1067,16 @@ def processStoredSms(self, unreadOnly=False):
         :param unreadOnly: If True, only process unread SMS messages
         :type unreadOnly: boolean
         """
-        if self.smsReceivedCallbackFunc:
+        if self.smsReceivedCallback:
             states = [Sms.STATUS_RECEIVED_UNREAD]
             if not unreadOnly:
                 states.insert(0, Sms.STATUS_RECEIVED_READ)
             for msgStatus in states:
                 messages = self.listStoredSms(status=msgStatus, delete=True)
                 for sms in messages:
-                    self.smsReceivedCallbackFunc(sms)
+                    self.smsReceivedCallback(sms)
         else:
-            raise ValueError('GsmModem.smsReceivedCallbackFunc not set')
+            raise ValueError('GsmModem.smsReceivedCallback not set')
 
     def listStoredSms(self, status=Sms.STATUS_ALL, memory=None, delete=False):
         """ Returns SMS messages currently stored on the device/SIM card.
@@ -1283,9 +1283,7 @@ def _handleIncomingCall(self, lines):
             callId = len(self.activeCalls) + 1;
             call = IncomingCall(self, callerNumber, ton, callerName, callId, callType)
             self.activeCalls[callId] = call
-
-        if self.incomingCallCallbackFunc:
-            self.incomingCallCallbackFunc(call)
+        self.incomingCallCallback(call)
 
     def _handleCallInitiated(self, regexMatch, callId=None, callType=1):
         """ Handler for "outgoing call initiated" event notification line """
@@ -1346,16 +1344,16 @@ def _handleCallRejected(self, regexMatch, callId=None):
     def _handleSmsReceived(self, notificationLine):
         """ Handler for "new SMS" unsolicited notification line """
         self.log.debug('SMS message received')
-        if self.smsReceivedCallbackFunc is not None:
+        if self.smsReceivedCallback is not None:
             cmtiMatch = self.CMTI_REGEX.match(notificationLine)
             if cmtiMatch:
                 msgMemory = cmtiMatch.group(1)
                 msgIndex = cmtiMatch.group(2)
                 sms = self.readStoredSms(msgIndex, msgMemory)
                 try:
-                    self.smsReceivedCallbackFunc(sms)
+                    self.smsReceivedCallback(sms)
                 except Exception:
-                    self.log.error('error in smsReceivedCallbackFunc', exc_info=True)
+                    self.log.error('error in smsReceivedCallback', exc_info=True)
                 else:
                     self.deleteStoredSms(msgIndex)
 
@@ -1374,12 +1372,12 @@ def _handleSmsStatusReport(self, notificationLine):
             if self._smsStatusReportEvent:
                 # A sendSms() call is waiting for this response - notify waiting thread
                 self._smsStatusReportEvent.set()
-            elif self.smsStatusReportCallbackFunc:
+            elif self.smsStatusReportCallback:
                 # Nothing is waiting for this report directly - use callback
                 try:
-                    self.smsStatusReportCallbackFunc(report)
+                    self.smsStatusReportCallback(report)
                 except Exception:
-                    self.log.error('error in smsStatusReportCallbackFunc', exc_info=True)
+                    self.log.error('error in smsStatusReportCallback', exc_info=True)
 
     def _handleSmsStatusReportTe(self, length, notificationLine):
         """ Handler for TE SMS status reports """
@@ -1402,10 +1400,9 @@ def _handleSmsStatusReportTe(self, length, notificationLine):
         else:
             # Nothing is waiting for this report directly - use callback
             try:
-                self.smsStatusReportCallbackFunc(report)
+                self.smsStatusReportCallback(report)
             except Exception:
-                self.log.error('error in smsStatusReportCallbackFunc', exc_info=True)
-
+                self.log.error('error in smsStatusReportCallback', exc_info=True)
 
     def readStoredSms(self, index, memory=None):
         """ Reads and returns the SMS message at the specified index
@@ -1543,6 +1540,10 @@ def _parseCusdResponse(self, lines):
             message = cusdMatches[0].group(2)
         return Ussd(self, sessionActive, message)
 
+    def _placeHolderCallback(self, *args):
+        """ Does nothing """
+        self.log.debug('called with args: {0}'.format(args))
+
     def _pollCallStatus(self, expectedState, callId=None, timeout=None):
         """ Poll the status of outgoing calls.
         This is used for modems that do not have a known set of call status update notifications.

gsmmodem/serial_comms.py

@@ -39,8 +39,8 @@ def __init__(self, port, baudrate=115200, notifyCallbackFunc=None, fatalErrorCal
         # Reentrant lock for managing concurrent write access to the underlying serial port
         self._txLock = threading.RLock()
 
-        self.notifyCallbackFunc = notifyCallbackFunc
-        self.fatalErrorCallbackFunc = fatalErrorCallbackFunc
+        self.notifyCallback = notifyCallbackFunc or self._placeholderCallback
+        self.fatalErrorCallback = fatalErrorCallbackFunc or self._placeholderCallback
 
         self.com_args = args
         self.com_kwargs = kwargs
@@ -78,10 +78,12 @@ def _handleLineRead(self, line, checkForResponseTerm=True):
                 # No more chars on the way for this notification - notify higher-level callback
                 #print 'notification:', self._notification
                 self.log.debug('notification: %s', self._notification)
-                if self.notifyCallbackFunc:
-                    self.notifyCallbackFunc(self._notification)
+                self.notifyCallback(self._notification)
                 self._notification = []
 
+    def _placeholderCallback(self, *args, **kwargs):
+        """ Placeholder callback function (does nothing) """
+
     def _readLoop(self):
         """ Read thread main loop
 
@@ -117,8 +119,7 @@ def _readLoop(self):
             except Exception: #pragma: no cover
                 pass
             # Notify the fatal error handler
-            if self.fatalErrorCallbackFunc:
-                self.fatalErrorCallbackFunc(e)
+            self.fatalErrorCallback(e)
 
     def write(self, data, waitForResponse=True, timeout=5, expectedResponseTermSeq=None):
         data = data.encode()