Re: Phone Detection Scheme

Is there a way I can get off of this mailing list?

----- Original Message -----
From: "Roger Binns" <[email protected]>
To: <[email protected]>
Sent: Wednesday, April 06, 2005 12:59 AM
Subject: Re: [BitPim-devel] Phone Detection Scheme


> > Based on Roger's suggestion, I'm looking for a good way of auto
> > detecting phones.  To do this properly and reliably, I think that each
> > phone model would have to implement its own detection routine.
>
> I would suggest a different approach.
>
> Gather information from the system such as what USB devices and
> com ports are connected, and send various Brew and AT command
> sequences to the ports (do the latter part in parallel so it doesn't
> take all day).
>
> Each phone module should then be able to rule itself out completely
> or be able to make a better determination based on the ports it
> sees available as well as AT command/Brew command responses.
>
> Since you like a challenge, here is some code for you to integrate
> as well that will auto-detect new ports being plugged in or removed.
> I have excerpted from the code I use to hibernate my machine when it
> has finished writing a DVD (the dvd software ejects the disc and
> that shows up as a device removal).
>
> First of all you need to change the window procedure for a window.
> I'd suggest the main one.
>
>         # save the old window proc
>         self.oldwndproc = win32gui.SetWindowLong(self.GetHandle(),
>                                                  win32con.GWL_WNDPROC,
>                                                  self.MyWndProc)
>
> Then define a new window procedure.
>
>     def MyWndProc(self, hwnd, msg, wparam, lparam):
>
>         if msg==win32con.WM_DEVICECHANGE:
>             type,params=DeviceChanged(wparam, lparam).GetEventInfo()
>             self.OnDeviceChanged(type, **params)
>             return True
>
>         # Restore the old WndProc.  Notice the use of win32api
>         # instead of win32gui here.  This is to avoid an error due to
>         # not passing a callable object.
>         if msg == win32con.WM_DESTROY:
>             win32api.SetWindowLong(self.GetHandle(),
>                                    win32con.GWL_WNDPROC,
>                                    self.oldwndproc)
>
>         # Pass all messages (in this case, yours may be different) on
>         # to the original WndProc
>         return win32gui.CallWindowProc(self.oldwndproc,
>                                        hwnd, msg, wparam, lparam)
>
> Make a self.OnDeviceChanged function that will be called with the relevant
> information.
>
>    def OnDeviceChanged(self, type, name="", drives=[], flag=None):
>         self.Log("%s: name %s, drives %s, flag %s\n" % (type,
name,`drives`,flag))
>
> This is the code that decodes the device change parameters into something
> useful.
>
> class DeviceChanged:
>
>     DBT_DEVICEARRIVAL = 0x8000
>     DBT_DEVICEQUERYREMOVE = 0x8001
>     DBT_DEVICEQUERYREMOVEFAILED = 0x8002
>     DBT_DEVICEREMOVEPENDING =  0x8003
>     DBT_DEVICEREMOVECOMPLETE = 0x8004
>     DBT_DEVICETYPESPECIFIC = 0x8005
>     DBT_DEVNODES_CHANGED = 7
>     DBT_CONFIGCHANGED = 0x18
>
>     DBT_DEVTYP_OEM = 0
>     DBT_DEVTYP_DEVNODE = 1
>     DBT_DEVTYP_VOLUME = 2
>     DBT_DEVTYP_PORT = 3
>     DBT_DEVTYP_NET = 4
>
>     DBTF_MEDIA   =   0x0001
>     DBTF_NET    =    0x0002
>
>     def __init__(self, wparam, lparam):
>         self._info=None
>         for name in dir(self):
>             if name.startswith("DBT") and not
name.startswith("DBT_DEVTYP") and getattr(self,name)==wparam:
>                 self._info=(name, dict(self._decode_struct(lparam)))
>
>     def GetEventInfo(self):
>         return self._info
>
>     def _decode_struct(self, lparam):
>         if lparam==0: return ()
>         format = "iii"
>         buf = win32gui.PyMakeBuffer(struct.calcsize(format), lparam)
>         dbch_size, dbch_devicetype, dbch_reserved = struct.unpack(format,
buf)
>
>         buf = win32gui.PyMakeBuffer(dbch_size, lparam) # we know true size
now
>
>         if dbch_devicetype==self.DBT_DEVTYP_PORT:
>             name=""
>             for b in buf[struct.calcsize(format):]:
>                 if b!="\x00":
>                     name+=b
>                     continue
>                 break
>             return ("name", name),
>
>         if dbch_devicetype==self.DBT_DEVTYP_VOLUME:
>             # yes, the last item is a WORD, not a DWORD like the hungarian
would lead you to think
>             format="iiiih0i"
>             dbcv_size, dbcv_devicetype, dbcv_reserved, dbcv_unitmask,
dbcv_flags = struct.unpack(format, buf)
>             units=[chr(ord('A')+x) for x in range(26) if
dbcv_unitmask&(2**x)]
>             flag=""
>             for name in dir(self):
>                 if name.startswith("DBTF_") and getattr(self,
name)==dbcv_flags:
>                     flag=name
>                     break
>
>             return ("drives", units), ("flag", flag)
>
>         print "unhandled devicetype struct", dbch_devicetype
>         return ()
>
> Roger
>
>
> -------------------------------------------------------
> SF email is sponsored by - The IT Product Guide
> Read honest & candid reviews on hundreds of IT Products from real users.
> Discover which products truly live up to the hype. Start reading now.
> http://ads.osdn.com/?ad_id=6595&alloc_id=14396&op=click
> _______________________________________________
> BitPim-devel mailing list
> [email protected]
> https://lists.sourceforge.net/lists/listinfo/bitpim-devel
>


-------------------------------------------------------
SF email is sponsored by - The IT Product Guide
Read honest & candid reviews on hundreds of IT Products from real users.
Discover which products truly live up to the hype. Start reading now.
http://ads.osdn.com/?ad_id=6595&alloc_id=14396&op=click