class DriverManagerUnitTest_A(unittest.TestCase): def setUp(self): self.testFolder = "test_A" loggingConfFolder = os.path.join(common.CONFIGS_FOLDER, common.LOGGING_CONF) logging.config.fileConfig(os.path.join(self.testFolder, loggingConfFolder)) self.deviceManager = DeviceManager(os.path.join(self.testFolder, common.getDevicesConfigFilePath()), os.path.join(mainProjectFolder, common.DRIVERS_FOLDER)) #getDeviceList() checking def testA(self): deviceList = self.deviceManager.getDeviceList() deviceList.sort() assert [{0: "Temperature sensor"}] == deviceList #sendCommand() checking def testB(self): deviceList = self.deviceManager.getDeviceList() deviceId = deviceList[0].keys()[0] result = self.deviceManager.sendCommand(json.loads('{"action":"get_temperature", "deviceId": 0}')) assert '{"temperature": 15}' == result #Bad Id sendCommand() checking def testC(self): result = self.deviceManager.sendCommand(json.loads('{"action":"get_temperature", "deviceId": 1}')) assert "['Bad request': 'Bad id!']" == result
def _runTestcase(self, *args, **kwds): try: deviceInfo = args[0]['deviceInfo'] testcase = args[0]['testcase'] testcase.testcaseResult.deviceInfo = json.dumps(deviceInfo.toDict()) TestcaseResultDao().insert(testcase.testcaseResult) uninstallCommand = "adb -s %s uninstall %s" % (deviceInfo.serial, testcase.package) TestcaseResultDao().update(testcase.testcaseResult, callCommand(uninstallCommand)) installCommand = "adb -s %s install %s" % (deviceInfo.serial, testcase.apkpath) TestcaseResultDao().update(testcase.testcaseResult, callCommand(installCommand)) for prepare in testcase.prepares: prepare = self._replaceMacro(prepare, deviceInfo, testcase); TestcaseResultDao().update(testcase.testcaseResult, callCommand(prepare)) for command in testcase.commands: command = self._replaceMacro(command, deviceInfo, testcase); TestcaseResultDao().update(testcase.testcaseResult, callCommand(command)) TestcaseResultDao().update(testcase.testcaseResult, callCommand("adb -s %s uninstall %s" % (deviceInfo.serial, testcase.package))) testcase.testcaseResult.isEnd = 1 testcase.testcaseResult.isSuccess = 1 TestcaseResultDao().update(testcase.testcaseResult) finally: DeviceManager().resetDevice(deviceInfo)
def run(self): ''' ModemManager.run() starts the ModemManager service ''' self.device_manager = DeviceManager(self.bus_name) self.device_manager.connect("device-added", self.__device_added) self.device_manager.connect("device-removed", self.__device_removed) self.mainloop.run()
def test_direction(): dm = DeviceManager() dm.add("wind_direction", WindDirectionDevice(529516, 0)) dm.waitUntilAllReady() while True: print(dm.get_event()) time.sleep(1)
def _processOnBackground(self): while True: if self.queue.empty(): time.sleep(1) continue testcase = self.queue.get() deviceInfo = DeviceManager().shiftDevice(testcase.condition) if not deviceInfo: self.queue.put(testcase) time.sleep(1) continue requests = makeRequests(self._runTestcase, [{'deviceInfo':deviceInfo, 'testcase':testcase}]) [ThreadPoolManager().threadPool.putRequest(req) for req in requests] ThreadPoolManager().threadPool.wait()
def __init__ (self, opath) : gobject.GObject.__init__(self) self.path = opath self.mcontroller = DeviceManager() self.device_dialer = DeviceDialer() self.dbus = self.mcontroller.dbus self.conf = tgcm.core.Config.Config() self.domain = MobileManager.CARD_DOMAIN_CS_PS self.mode = MobileManager.CARD_TECH_SELECTION_AUTO domain = self.conf.get_last_domain() mode = self.conf.get_last_device_mode() if domain == "cs_ps" : self.domain = MobileManager.CARD_DOMAIN_CS_PS elif domain == "cs" : self.domain = MobileManager.CARD_DOMAIN_CS elif domain == "ps" : self.domain = MobileManager.CARD_DOMAIN_PS if mode == "auto" : self.mode = MobileManager.CARD_TECH_SELECTION_AUTO elif mode == "gsm" : self.mode = MobileManager.CARD_TECH_SELECTION_GPRS elif mode == "wcdma" : self.mode = MobileManager.CARD_TECH_SELECTION_UMTS elif mode == "gsm_first" : self.mode = MobileManager.CARD_TECH_SELECTION_GRPS_PREFERED elif mode == "wcdma_first" : self.mode = MobileManager.CARD_TECH_SELECTION_UMTS_PREFERED self.__addressbook = self.__get_device_addressbook_from_path(self.path) self.__info = self.__get_device_info_from_path(self.path) self.__auth = self.__get_device_auth_from_path(self.path) self.__state = self.__get_device_state_from_path(self.path) self.__sms = self.__get_device_sms_from_path(self.path) self.cache = {} self.mcontroller.connect("dev-roaming-status-changed", self.__DevRoamingActStatusChanged_cb) self.mcontroller.connect("dev-card-status-changed", self.__DevCardStatusChanged_cb)
class Device(gobject.GObject) : def __init__ (self, opath) : gobject.GObject.__init__(self) self.path = opath self.mcontroller = DeviceManager() self.device_dialer = DeviceDialer() self.dbus = self.mcontroller.dbus self.conf = tgcm.core.Config.Config() self.domain = MobileManager.CARD_DOMAIN_CS_PS self.mode = MobileManager.CARD_TECH_SELECTION_AUTO domain = self.conf.get_last_domain() mode = self.conf.get_last_device_mode() if domain == "cs_ps" : self.domain = MobileManager.CARD_DOMAIN_CS_PS elif domain == "cs" : self.domain = MobileManager.CARD_DOMAIN_CS elif domain == "ps" : self.domain = MobileManager.CARD_DOMAIN_PS if mode == "auto" : self.mode = MobileManager.CARD_TECH_SELECTION_AUTO elif mode == "gsm" : self.mode = MobileManager.CARD_TECH_SELECTION_GPRS elif mode == "wcdma" : self.mode = MobileManager.CARD_TECH_SELECTION_UMTS elif mode == "gsm_first" : self.mode = MobileManager.CARD_TECH_SELECTION_GRPS_PREFERED elif mode == "wcdma_first" : self.mode = MobileManager.CARD_TECH_SELECTION_UMTS_PREFERED self.__addressbook = self.__get_device_addressbook_from_path(self.path) self.__info = self.__get_device_info_from_path(self.path) self.__auth = self.__get_device_auth_from_path(self.path) self.__state = self.__get_device_state_from_path(self.path) self.__sms = self.__get_device_sms_from_path(self.path) self.cache = {} self.mcontroller.connect("dev-roaming-status-changed", self.__DevRoamingActStatusChanged_cb) self.mcontroller.connect("dev-card-status-changed", self.__DevCardStatusChanged_cb) def __get_device_addressbook_from_path(self, dev_path): dev = self.dbus.get_object(MOBILE_MANAGER_DEVICE_URI, dev_path) dev_addressbook = dbus.Interface(dev, MOBILE_MANAGER_DEVICE_ADDRESSBOOK_INTERFACE_URI) return dev_addressbook def __get_device_info_from_path(self, dev_path): dev = self.dbus.get_object(MOBILE_MANAGER_DEVICE_URI, dev_path) dev_info = dbus.Interface(dev, MOBILE_MANAGER_DEVICE_INFO_INTERFACE_URI) return dev_info def __get_device_auth_from_path(self, dev_path): dev = self.dbus.get_object(MOBILE_MANAGER_DEVICE_URI, dev_path) dev_auth = dbus.Interface(dev, MOBILE_MANAGER_DEVICE_AUTH_INTERFACE_URI) return dev_auth def __get_device_state_from_path(self, dev_path): dev = self.dbus.get_object(MOBILE_MANAGER_DEVICE_URI, dev_path) dev_state = dbus.Interface(dev, MOBILE_MANAGER_DEVICE_STATE_INTERFACE_URI) return dev_state def __get_device_sms_from_path(self, dev_path): dev = self.dbus.get_object(MOBILE_MANAGER_DEVICE_URI, dev_path) dev_sms = dbus.Interface(dev, MOBILE_MANAGER_DEVICE_SMS_INTERFACE_URI) return dev_sms # ADDRESSBOOK INTERFACE @addressbook_interface_required @check_device @mobile_manager def addressbook_list_contacts(self): return self.__addressbook.ListContacts() # INFO INTERFACE @mobile_manager def get_capabilities(self): if self.cache.has_key("capabilities") : return self.cache["capabilities"] else: ret = self.__info.GetCapabilities() self.cache["capabilities"] = ret return ret @mobile_manager def has_capability(self, capability): if self.cache.has_key("capabilities") : if capability in self.cache["capabilities"]: return True else: return False else: ret = self.__info.GetCapabilities() self.cache["capabilities"] = ret return self.__info.HasCapability(capability) @mobile_manager def get_velocity(self): return self.__info.GetVelocity() @mobile_manager def set_velocity(self, value): self.__info.SetVelocity(value) @mobile_manager def get_prettyname(self): if self.cache.has_key("prettyname") : return self.cache["prettyname"] else: ret = self.__info.GetPrettyName() self.cache["prettyname"] = ret return ret @mobile_manager def get_MSISDN (self): if self.cache.has_key("MSDISDN") : return self.cache["MSDISDN"] else: ret = self.__info.GetMSISDN() if ret != "": self.cache["MSDISDN"] = ret return ret @mobile_manager def get_device_icon(self): if self.cache.has_key("icon") : return self.cache["icon"] else: ret = self.__info.GetDeviceIcon() self.cache["icon"] = ret return ret @mobile_manager def get_priority(self): if self.cache.has_key("priority") : return self.cache["priority"] else: ret = self.__info.GetPriority() self.cache["priority"] = ret return ret @mobile_manager def set_prority(self, priority): self.cache["priority"] = priority return self.__info.SetPriority(priority) @mobile_manager def is_multiport_device(self): if self.cache.has_key("is_multiport") : return self.cache["is_multiport"] else: ret = self.__info.IsMultiPortDevice() self.cache["is_multiport"] = ret return ret @mobile_manager def get_data_device_path(self): return self.__info.GetDataDevicePath() @mobile_manager def get_hardware_flow_control(self): return self.__info.GetHardwareFlowControl() @mobile_manager def get_hardware_error_control(self): return self.__info.GetHardwareErrorControl() @mobile_manager def get_hardware_compress(self): return self.__info.GetHardwareCompress() @mobile_manager def set_hardware_flow_control(self, value): self.__info.SetHardwareFlowControl(value) @mobile_manager def set_hardware_error_control(self, value): self.__info.SetHardwareErrorControl(value) @mobile_manager def set_hardware_compress(self, value): self.__info.SetHardwareCompress(value) # AUTH INTERFACE @auth_interface_required @device_ready_required @mobile_manager def is_pin_active(self): return self.__auth.IsPINActive() @auth_interface_required @device_ready_required @mobile_manager def set_pin_active(self, pin, active): return self.__auth.SetPINActive(pin, active) @auth_interface_required @mobile_manager def pin_status(self): return self.__auth.PINStatus() @auth_interface_required @mobile_manager def send_pin(self, pin): return self.__auth.SendPIN(pin) @auth_interface_required @device_ready_required @mobile_manager def set_pin(self, old_pin, new_pin): return self.__auth.SetPIN(old_pin, new_pin) @auth_interface_required @mobile_manager def send_puk(self, puk, pin): return self.__auth.SendPUK(puk, pin) # STATUS INTERFACE @state_interface_required @device_ready_required @mobile_manager def get_card_info(self): if self.cache.has_key("cardinfo") : return self.cache["cardinfo"] else: ret = self.__state.GetCardInfo() self.cache["cardinfo"] = ret return ret @state_interface_required @mobile_manager def get_card_status(self): if self.device_dialer.status() != PPP_STATUS_DISCONNECTED and not self.is_multiport_device() : return CARD_STATUS_READY return self.__state.GetCardStatus() @mobile_manager def get_imsi (self): if self.cache.has_key("imsi"): return self.cache["imsi"] else: ret = self.__state.GetImsi() self.cache["imsi"] = ret return ret def get_imsi_safe (self): if self.cache.has_key("imsi"): return self.cache["imsi"] if self.has_capability(MOBILE_MANAGER_DEVICE_STATE_INTERFACE_URI): if self.get_card_status() == CARD_STATUS_READY : if self.device_dialer.status() != PPP_STATUS_DISCONNECTED and not self.is_multiport_device(): return "" else: ret = self.get_imsi() if ret == None : return "" return ret else: return "" else: return "" @state_interface_required @mobile_manager def turn_off(self): return self.__state.TurnOff() @state_interface_required @mobile_manager def turn_on(self): return self.__state.TurnOn() @state_interface_required @mobile_manager def is_on(self): return self.__state.IsOn() @state_interface_required @mobile_manager def is_attached(self): return self.__state.IsAttached() @state_interface_required @mobile_manager def set_carrier_auto_selection(self): return self.__state.SetCarrierAutoSelection() @state_interface_required @mobile_manager def is_carrier_auto(self): return self.__state.IsCarrierAuto() @state_interface_required @device_ready_required @mobile_manager def is_postpaid(self): if tgcm.country_support != "de": return self.__state.IsPostpaid() else: imsi = self.get_imsi () prepay_imsis = ["2620749", "26207500", "26207515", "26207516", "26207511"] for imsi_aux in prepay_imsis: if imsi.startswith (imsi_aux): return False return True @state_interface_required @device_ready_required @mobile_manager def get_cover_key(self, key, rfunc, efunc): self.__state.GetUSSDCmd(key, reply_handler=rfunc, error_handler=efunc) @state_interface_required @device_ready_required @mobile_manager def is_roaming(self): if (os.path.exists(os.path.join(tgcm.config_dir, "roaming"))) : return True if self.cache.has_key("roaming") : return self.cache["roaming"] else: if self.device_dialer.status() != PPP_STATUS_DISCONNECTED and not self.is_multiport_device() : tgcm.debug("MMC : return not roaming, because MM don't know this info and can't ask it") return False if self.has_capability(MOBILE_MANAGER_DEVICE_STATE_INTERFACE_URI) : ret = self.__state.IsRoaming() self.cache["roaming"] = ret return ret else: self.cache["roaming"] = False return False @state_interface_required @device_ready_required @mobile_manager def set_mode_domain(self, mode=None, domain=None): d = domain m = mode if d == None : d = self.domain if m == None : m = self.mode if d == MobileManager.CARD_DOMAIN_CS_PS : tgcm.info ("Setting DOMAIN : CS_PS") elif d == MobileManager.CARD_DOMAIN_CS : tgcm.info ("Setting DOMAIN : CS") elif d == MobileManager.CARD_DOMAIN_PS : tgcm.info ("Setting DOMAIN : PS") if m == MobileManager.CARD_TECH_SELECTION_AUTO : tgcm.info ("Setting MODE : AUTO") elif m == MobileManager.CARD_TECH_SELECTION_GPRS : tgcm.info ("Setting MODE : GPRS") elif m == MobileManager.CARD_TECH_SELECTION_UMTS : tgcm.info ("Setting MODE : UMTS") elif m == MobileManager.CARD_TECH_SELECTION_GRPS_PREFERED : tgcm.info ("Setting MODE : GPRS_PREF") elif m == MobileManager.CARD_TECH_SELECTION_UMTS_PREFERED : tgcm.info ("Setting MODE : UMTS_PREF") if self.__state.SetModeDomain(m, d) : self.mode = m self.domain = d return @state_interface_required @device_ready_required @mobile_manager def get_mode_domain(self): return self.__state.GetModeDomain() @state_interface_required @device_ready_required @mobile_manager def set_carrier(self, value1, value2): return self.__state.SetCarrier(value1, value2) @state_interface_required @device_ready_required @mobile_manager def get_carrier_list(self, reply_handler, error_handler): return self.__state.GetCarrierList(reply_handler=reply_handler, error_handler=error_handler, timeout=2000000) # SMS INTERFACE @sms_interface_required @device_ready_required @mobile_manager def sms_send (self, number, smsc, text, rfunc, efunc, request_status=False): if request_status == False : self.__sms.Send(number, smsc, text, timeout=2000000, reply_handler=rfunc, error_handler=efunc) else: self.__sms.SendWithRequestStatus(number, smsc, text, timeout=2000000, reply_handler=rfunc, error_handler=efunc) @sms_interface_required @device_ready_required @mobile_manager def sms_get_draft (self, index): return self.__sms.GetDraft (index) @sms_interface_required @device_ready_required @mobile_manager def sms_set_draft (self, number, text): return self.__sms.SetDraft (number, text) @sms_interface_required @device_ready_required @mobile_manager def sms_edit_draft (self, index, number, text): return self.__sms.EditDraft (index, number, text) @sms_interface_required @device_ready_required @mobile_manager def sms_delete_draft (self, index): return self.__sms.DeleteDraft (index) @sms_interface_required @device_ready_required @mobile_manager def sms_list_drafts (self): return self.__sms.ListDrafts () def __rewrite_received_item(self, i,r,sender,d,msg) : if "SR-OK" in sender : sender = _("Notification") recipient, scts, dt = msg.split("|") new_msg = _("The SMS for %s, sent on %s at %s, has been delivered on %s at %s.") % (recipient, scts.split()[0], scts.split()[1], dt.split()[0], dt.split()[1]) return (i,r,sender,d,new_msg) elif "SR-UNKNOWN" in sender : sender = _("Notification") recipient, scts, dt = msg.split("|") new_msg = _("There has been an error while sending the SMS for %s, sent on %s at %s. ") % (recipient, scts.split()[0], scts.split()[1]) return (i,r,sender,d,new_msg) elif "SR-STORED" in sender : sender = _("Notification") recipient, scts, dt = msg.split("|") new_msg = _("The SMS for %s, sent on %s at %s, has been stored in the short message service center.") % (recipient, scts.split()[0], scts.split()[1]) return (i,r,sender,d,new_msg) else: return (i,r,sender,d,msg) @sms_interface_required @device_ready_required @mobile_manager def sms_get_received (self, index): i,r,sender,d,msg = self.__sms.GetReceived (index) return self.__rewrite_received_item(i,r,sender,d,msg) @sms_interface_required @device_ready_required @mobile_manager def sms_delete_received (self, index): return self.__sms.DeleteReceived (index) @sms_interface_required @device_ready_required @mobile_manager def sms_list_received (self): ret = self.__sms.ListReceived () received_list = [] for i,r,sender,d in ret : if sender.startswith("SR-") : sender = _("Notification") received_list.append((i,r,sender,d)) return received_list @sms_interface_required @device_ready_required @mobile_manager def sms_mark_received_readed (self, index): return self.__sms.MarkReceivedReaded (index) @sms_interface_required @device_ready_required @mobile_manager def sms_mark_received_unreaded (self, index): return self.__sms.MarkReceivedUnreaded (index) @sms_interface_required @device_ready_required @mobile_manager def sms_get_sended (self, index): return self.__sms.GetSended (index) @sms_interface_required @device_ready_required @mobile_manager def sms_delete_sended (self, index): return self.__sms.DeleteSended (index) @sms_interface_required @device_ready_required @mobile_manager def sms_list_sended (self): return self.__sms.ListSended () @sms_interface_required @device_ready_required @mobile_manager def sms_mark_sended_readed (self, index): return self.__sms.MarkSendedReaded (index) @sms_interface_required @device_ready_required @mobile_manager def sms_mark_sended_unreaded (self, index): return self.__sms.MarkSendedUnreaded (index) def __DevRoamingActStatusChanged_cb(self, mcontroller, device, status): if self.path == device : self.cache["roaming"] = status tgcm.debug("Caching roaming value (%s , %s, %s)" % (self, device, status)) def __DevCardStatusChanged_cb(self, mcontroller, device, status): if self.path == device : if status == CARD_STATUS_READY : if not self.cache.has_key("imsi") : self.get_imsi_safe() try: self.get_card_info() except: pass
def setUp(self): self.testFolder = "test_A" loggingConfFolder = os.path.join(common.CONFIGS_FOLDER, common.LOGGING_CONF) logging.config.fileConfig(os.path.join(self.testFolder, loggingConfFolder)) self.deviceManager = DeviceManager(os.path.join(self.testFolder, common.getDevicesConfigFilePath()), os.path.join(mainProjectFolder, common.DRIVERS_FOLDER))
#raspberry pi states remote query service #winxos 2016-6-10 import socket import time from DeviceManager import DeviceManager version="1.0" port=9000 s=socket.socket(socket.AF_INET, socket.SOCK_DGRAM) s.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1) s.setsockopt(socket.SOL_SOCKET,socket.SO_BROADCAST,1) s.bind(('',port)) if __name__=='__main__': print("query service starting...") dm=DeviceManager() while True: data,addr=s.recvfrom(1024) print("%s:%s"%(addr,data)) datas=data.split() if len(datas)==0:continue if datas[0]=="RPI": if len(datas)==1: s.sendto("IPR",addr) else: t=datas[1] if t=="NAME": s.sendto(socket.gethostname(),addr) elif t=="VERSION": s.sendto(version,addr) elif t=="DEVICES": s.sendto(dm.list_devices(),addr) elif t=="DEVICE":
class ModemManager(DbusObject): ''' ModemManager is the main class of mobile-manager2. It creates a dbus interface freedesktop ModemManager. ''' def __init__(self, on_system_bus=True): dbus.mainloop.glib.DBusGMainLoop(set_as_default=True) self.mainloop = gobject.MainLoop() if on_system_bus == False : self.bus_name = BusName("org.gnome.MobileManager", dbus.SessionBus()) else: self.bus_name = BusName(MM_SERVICE, dbus.SystemBus()) DbusObject.__init__(self, self.bus_name, MM_PATH) def run(self): ''' ModemManager.run() starts the ModemManager service ''' self.device_manager = DeviceManager(self.bus_name) self.device_manager.connect("device-added", self.__device_added) self.device_manager.connect("device-removed", self.__device_removed) self.mainloop.run() @method(MM_URI, in_signature = '', out_signature = 'ao', method_name="EnumerateDevices") def enumerate_devices(self): ''' [DBUS Method exported] List of object paths of modem devices known to the system. ''' return self.device_manager.enumerate_devices() @signal(MM_URI, signature = 'o', signal_name = 'DeviceAdded') def device_added(self, object): ''' [DBUS signal exported] The object path of the newly added device. ''' pass def __device_added(self, dm, obj): self.device_added(obj) info("DBUS (signal:DeviceAdded:(%s))" % (obj)) @signal(MM_URI, signature = 'o', signal_name = 'DeviceRemoved') def device_removed(self, object): ''' [DBUS signal exported] A device was removed from the system, and is no longer available. ''' pass def __device_removed(self, dm, obj): self.device_removed(obj) info("DBUS (signal:DeviceRemoved:(%s))" % (obj))
def __init__(self): self.threadNumber = len(DeviceManager().getDeviceInfoList().available_device_list) * 2 self.threadPool = threadpool.ThreadPool(self.threadNumber)