Jumping Jack Flash weblog

Leggere il contenuto della clibpoard DI SISTEMA

Posted in Java, jython, Motorola a1000, Symbian, Symbian UIQ by jumpjack on 22 febbraio 2007

import java.awt.Toolkit

import java.awt.datatransfer

tk = java.awt.Toolkit

dt=tk.getDefaultToolkit()

cl=dt.getSystemClipboard()

a= java.lang.Object

cont = cl.getContents(a)

dfs=cont.getTransferDataFlavors()

val=cont.getTransferData(dfs[0])

Elenco font disponibili in Jython/PersonalJava

Posted in Java, jython, Motorola a1000, Symbian, Symbian UIQ by jumpjack on 19 febbraio 2007

import java.awt.Toolkit

t = java.awt.Toolkit

t.getDefaultToolkit().getFontList()

Codici di tastiera Motorola a1000 (OPL)

Posted in Motorola a1000, Symbian, Symbian UIQ by jumpjack on 18 febbraio 2007

Joy up 63558
Joy down 63559
Joy left 63560
Joy right 63561
Fire 63542
Game A 63580
Game B 63581?
On/Off 63567

Altri tasti: non rilevabili in OPL

Tasti “teorici”:
Prossimo campo: 0xf6dc
Campo precedente: 0xf6dd
Inizio riga: 0xf802
Fine riga: 0xf803
Cursore alto: 0xf809
Cursore basso: 0xf80a
Cursore sinistra: 0xf807
Cursore destra: 0xf808

Accedere alla porta COM dell’a1000 con le Javaphone API

Posted in Java, Javaphone API, Motorola a1000, Symbian, Symbian UIQ by jumpjack on 15 febbraio 2007

http://www.jugsardegna.org/vqwiki/jsp/Wiki?action=action_view_attachment&attachment=JavaComm_Macomer2006.pdf

http://www2.mokabyte.it/cms/article.run?articleId=IMR-4TE-FU8-AKB_7f000001_30480431_06a21703

http://www.mokabyte.it/2000/01/jca.htm

import javax.comm.CommPortIdentifier

cpi = javax.comm.CommPortIdentifier

portid = cpi.getPortIdentifier(“COM1”)

port = portid.open(“MiaApplicazione”,5000)  # Stringa arbitraria che dice al Sistema quale applicazione sta richiedendo l’uso della porta; massimo tempo di attesa per ottenere il possesso della porta.

port.setSerialPortParams(115200,port.DATABITS_8,port.STOPBITS_1,port.PARITY_NONE)  # parametri consentiti: da verificare

# parametri per GPS (forse…):
port.setSerialPortParams(4800, SerialPort.DATABITS_8,SerialPort.STOPBITS_1, SerialPort.PARITY_NONE);

formato stringa NMEA (GPS):

$GPGGA,164922.982,3859.4108,N,00856.1785,E,1,04,3.4,127.9,M
$GPGGA,xxxx, lat, N, long, E, 1, NumSats, 3.4, altitudine ,M

Lettura dati:
inputbuf = port.getInputStream()
byte= inputbuf.read()

Elencare le porte disponibili sull’a1000 usando le Javaphone API

Posted in Java, Javaphone API, Motorola a1000, Symbian, Symbian UIQ by jumpjack on 15 febbraio 2007

>>> import javax.comm.CommPortIdentifier

>>> cpi = javax.comm.CommPortIdentifier

>>> ids = cpi.getPortIdentifiers()

>>> for i in range(0,22):

>>>    ids[i].getName()

risultato:

16 porte da “IPCCH::00” a “IPCCH::15”

5 porte “ACM1CH::00” a “ACM1CH:4”

porta “COM1”

porta “IRCOM1”

FTP con Jython

Posted in Motorola a1000, Symbian, Symbian UIQ by jumpjack on 13 febbraio 2007

Con l’a1000 è possibile uploadare e downloadare facilmente file a/da server FTP, senza bisogno di scaricare programmi shareware: è sufficiente JythonQ e uno script come questo:

import ftplib
import os
ftp = ftplib.FTP(”ftp.fbi.gov”)
ftp.login(”mulder”, “trustno1″)
[/code]

per cambiare cartella:
ftp.cwd(“nomecartella“)

per avere la lista dei file di una cartella:
ftp.retrlines(‘LIST’

per INVIARE un file:
ftp.storbinary(”STOR ” + nomefile, open(nomefile, “rb”))

per RICEVERE un file:
ftp.retrbinary(‘RETR nomefile, open(nomefile, ‘wb’).write)

Rilevare una chiamata in Jython con le Javaphone API

Posted in Java, Javaphone API, jython, Motorola a1000, Symbian, Symbian UIQ by jumpjack on 13 febbraio 2007

Ho “esteso” lo script jython di un precedente post: adesso il programma è in grado di accrogersi di una chiamata in arrivo, di leggere il numero del chiamante, e di scegliere di conseguenza se accettare la chiamata o rifiutarla.

Purtroppo sull’a1000 non è possibile nè rispondere alla chiamata nè rifiutarla: in entrambi i casi, infatti, il programma funziona, cioè accetta o rifiuta la chiamata… ma l’applicazione Phone non se ne accorge, e resta ad aspettare all’infinito che l’utente risponda o riagganci… anche se la telefonata in realtà è già stata accettata o rifiutata dallo script Jython!

Un’alternativa sarebbe far inviare dallo scipt Jython una “simulazione di tasto premuto” all’applicazione Phone, in modo da “premere” il tasto “occupato” o “rispondi” nel dialog che appare all’arrivo di una chiamata. Ma bisogna vedere se è tecnicamente possibile.
import javax.telephony.events
import os
import java.lang
import com.symbian.javax.telephony.mobile
import com.symbian.javax.telephony
import com.symbian.epoc.etel
import java.lang.Integer
import java.lang.String
import javax.net.datagram
import com.symbian.javax.net.datagram
from java.awt import Frame,MenuBar,Menu,MenuItem,TextArea,FileDialog
from java.awt.event import ActionEvent

class test(java.awt.Frame, com.symbian.epoc.etel.EtelLineListener):
def __init__(self):
self.size=(208,276)
self.myOutput=java.awt.TextArea(“Hello UIQ from Jython!!!\n”)
self.add(“Center”,self.myOutput)
self.myMenuBar=java.awt.MenuBar()
self.myMenu=java.awt.Menu(“Menu”)
self.myReadFile=java.awt.MenuItem(“Start”,actionPerformed=self.doStart) # Avvio routine principale da menu
self.myMenuExit=java.awt.MenuItem(“Exit”,actionPerformed=self.doExit)
self.myMenuBar.add(self.myMenu)
self.myMenu.add(self.myReadFile)
self.myMenu.add(self.myMenuExit)
self.setMenuBar(self.myMenuBar)
self.setVisible(1)

def doStart(self,event):
p=com.symbian.javax.telephony.mobile.EpocGsmMobileProvider()
ts=p.getTerminals()
t=ts[0]
tads=t.getAddresses()
tad=tads[0]
m=com.symbian.javax.telephony.mobile.EpocGsmMobileTerminal(tad,p)
mads=m.getAddresses()
m=mads[0]
print “Numero SIM:”,m.getSubscriptionId()
IMSIFile=open(“c:\\system\\data\\e32user.bin”,’r’)
IMSI=IMSIFile.read()
print “Numero registrato: \n”,IMSI
if java.lang.Integer.toString(m.getSubscriptionId()) != IMSI:
print “BRUTTO LADRONE!!!\n”
jnd=javax.net.datagram
dns=jnd.DatagramNameService
addr=com.symbian.javax.net.datagram.SMSAddress(“xxxxx”)
ds=jnd.DatagramService
serv=ds.getService(addr)
mex=java.lang.String(“ti hanno fregato il cellulare!!!”).getBytes()
d=jnd.Datagram(mex,addr)
serv.send(d)

def doExit(self,event):
java.lang.System.exit(0)

def callActive(self,event): #callListener (mai rilevato???)
print “callActive (callListener)\n”

def callInvalid(self,event): #callListener (mai rilevato???)
print “callInvalid (callListener)”

def callEventTransmissionEnded(self,event): #callListener
print “eventocallEventTransmissionEnded: ( callListener)”, event

def statusChange(self, line, num): # etelline, status (da EtelLineListener)
print “*********STATUSCHANGE*********”
print “Stato attuale: “, num , “\n”
self.myOutput.appendText(“Current call status: ” + java.lang.Integer.toString(num)+ “\n”)

def incomingCall(self, line, call): # etelline, etelcall (da EtelLineListener)
print ” —– INCOMING CALL —–”
self.myOutput.appendText(“INCOMING ” + call.getCallerId() + “…\n”)
print “->incoming call ‘” + call.getCallerId()
# print “prima rispondo,…”
# call.answer() # applicazione Phone si blocca!!
# print “…poi riattacco!”
# call.hangup() # applicazione Phone si blocca!!

def connectionAlerting(self,event):
print “Chiamata in arrivo da numero ”
incomingCall=event.getCall()
conns=incomingCall.getConnections()
# print “Numero connessioni ALERTING: “,len(conns)
addr1=conns[0].getAddress()
addr2=conns[1].getAddress()
numero1=addr1.getName() # Probabilmente numero LOCALE.
numero2=addr2.getName()
# print “1: ” + numero1 + “\n”
self.myOutput.appendText(“Chiamata in arrivo da ” + numero2 + “…”)
print numero2 + “\n”
#da qui non si puo’ riagganciare: solo da metodo incomingCall().

“””
def connectionConnected(self,event):
print “connectionConnected”
def connectionCreated(self,event):
print “connectionCreated: “, event
def connectionDisconnected(self,event):
print “connectionDisconnected”
def connectionFailed(self,event):
print “connectionFailed”
def connectionInProgress(self,event):
print “connectionInProgress”
def connectionUnknown(self,event):
print “connectionUnknown”
“””

if __name__==”__main__”:
myApp=test()

peer=com.symbian.javax.telephony.EpocJtapiPeer()
p=peer.getProvider(“EpocGsmMobileProvider”)
terms=p.getTerminals()
term=terms[0]
addrs=p.getAddresses()
addr=addrs[0]
lines1 = p.getPhone().getVoiceLines()
line1 = lines1[0]
lines2 = p.getVoiceLines()
line2 = lines2[0]
#addr.addCallListener(test()) # aggancia Listener all’Address
term=com.symbian.javax.telephony.mobile.EpocGsmMobileTerminal(addr,p)
#term.addCallListener(test())
line1.addLineListener(test())

print “READY.”

“””
ETEL CALL
public static final int STATUS_UNKNOWN = 0;
public static final int STATUS_IDLE = 1;
public static final int STATUS_DIALLING = 2;
public static final int STATUS_RINGING = 3;
public static final int STATUS_ANSWERING = 4;
public static final int STATUS_CONNECTING = 5;
public static final int STATUS_CONNECTED = 6;
public static final int STATUS_HANGING_UP = 7;

CONNECTION
public static final int IDLE = 48;
public static final int INPROGRESS = 49;
public static final int ALERTING = 50;
public static final int CONNECTED = 51;
public static final int DISCONNECTED = 52;
public static final int FAILED = 53;
public static final int UNKNOWN = 54;

TERMINAL CONNECTION
public static final int IDLE = 64;
public static final int RINGING = 65;
public static final int PASSIVE = 66;
public static final int ACTIVE = 67;
public static final int DROPPED = 68;
public static final int UNKNOWN = 69;

TERMINAL CONNECTION EVENT
public static final int TERMINAL_CONNECTION_ACTIVE = 115;
public static final int TERMINAL_CONNECTION_CREATED = 116;
public static final int TERMINAL_CONNECTION_DROPPED = 117;
public static final int TERMINAL_CONNECTION_PASSIVE = 118;
public static final int TERMINAL_CONNECTION_RINGING = 119;
public static final int TERMINAL_CONNECTION_UNKNOWN = 120;

CALL
public static final int IDLE = 32;
public static final int ACTIVE = 33;
public static final int INVALID = 34;

CALL EVENT
public static final int CALL_ACTIVE = 101;
public static final int CALL_INVALID = 102;
public static final int CALL_EVENT_TRANSMISSION_ENDED = 103;

CONNECTION EVENT
public static final int CONNECTION_ALERTING = 104;
public static final int CONNECTION_CONNECTED = 105;
public static final int CONNECTION_CREATED = 106;
public static final int CONNECTION_DISCONNECTED = 107;
public static final int CONNECTION_FAILED = 108;
public static final int CONNECTION_IN_PROGRESS = 109;
public static final int CONNECTION_UNKNOWN = 110;

SINGLE CALL META EVENT
public static final int SINGLECALL_META_PROGRESS_STARTED = 210;
public static final int SINGLECALL_META_PROGRESS_ENDED = 211;
public static final int SINGLECALL_META_SNAPSHOT_STARTED = 212;
public static final int SINGLECALL_META_SNAPSHOT_ENDED = 213;

ADDRESS_EVENT_TRANSMISSION_ENDED = 100

“””

Rilevare una chiamata in Jython – vecchio post

Posted in Java, Javaphone API, jython, Motorola a1000, Symbian, Symbian UIQ by jumpjack on 9 febbraio 2007

Questo post si è evoluto in quest’altro più completo

Per intercettare una chiamata usando Jython e Javaphone API bisogna usare listener ed eventi di Java.

Quando una classe Java implementa un listener, ogni volta che si verifica un evento gestito da quel listener esso verrà “inoltrato” alla classe; questa lo potrà gestire se contiene un metodo che ha lo stesso nome dell’evento.

Una chiamata è gestita dal listener CallListener. L’arrivo di una chiamata causa un evento callActive(CallEvent event). Il metodo Event.getID() restituisce il tipo di evento: CALL_ACTIVE, CALL_INVALID, CALL_EVENT_TRANSMISSION_ENDED.

Partendo da questo sorgente di esempio:

class action(awt.event.ActionListener):
def actionPerformed(self,event):
java.lang.System.exit(0)

button = awt.Button(“Close Me!”) button.addActionListener(action())

che equivale a questo:

def exit(event):
java.lang.System.exit(0)

button = awt.Button(“Close Me!”, actionPerformed=exit)

si può provare a dedurre il codice Jython necessario a rilevare una chiamata in arrivo:

class gestisciChiamate(java.awt.Frame, javax.telephony.CallListener):
def callActive(self,event):
print “E’ arrivata una chiamata!”

Bisogna però “agganciare” le chiamate alla classe. Se aver definito la classe non è sufficiente, forse bisogna aggiungere un listener all’address del telefono:

“In order to register as a listener for events reported for all calls involving a specific Address, as soon as the Calls are created, an application may implement the CallListener interface and then register with the Address, via the Address.addCallListener method.”

Bisogna quindi “prendere” un Address dal Provider, e applicargli il metodo addListener; tutto questo dovrà essere fatto FUORI dalla classe, nell’inizializzazione del programma (o nel metodo __init__):

[…]
import com.symbian.javax.telephony
peer = com.symbian.javax.telephony.EpocJtapiPeer()
myprovider = peer.getProvider(“EpocGsmMobileProvider”)
terms = myprovider.getTerminals
term = terms[0]
term.addCallListener(gestisciChiamate())

Realizzare un “antifurto” per cellulari in Jython

Posted in jython, Motorola a1000, Programmazione, Symbian, Symbian UIQ by jumpjack on 9 febbraio 2007

In Jython è possibile leggere il numero della carta SIM (IMSI), leggere dati da file e inviare messaggi di nascosto dall’utente, senza che vengano nemmeno salvati in OUTBOX.

Combinando le tre cose, è possibile scrivere un programma che rileva se nel cellulare viene inserita una SIM diversa da quella originale, e in quel caso inviare un messaggio a un numero predefinito.

Ecco una bozza di possibile programma, che però effettua il controllo alla scelta della prima voce di menu: il vero “antifurto” dovrà invece ovviamente fare il controllo appena il programma parte, e tale programma dovrà essere messo in autoavvio.

import os
import java.lang
import com.symbian.javax.telephony.mobile
import java.lang.Integer
import java.lang.String
import javax.net.datagram
import com.symbian.javax.net.datagram
from java.awt import Frame,MenuBar,Menu,MenuItem,TextArea,FileDialog
from java.awt.event import ActionEvent
class test(java.awt.Frame):
-á -á def __init__(self):
-á -á -á -á self.size=(208,276)
-á -á -á -á self.myOutput=java.awt.TextArea(“Selezionare il menu ‘Verifica’.”)
-á -á -á -á self.add(“Center”,self.myOutput)
-á -á -á -á self.myMenuBar=java.awt.MenuBar()
-á -á -á -á self.myMenu=java.awt.Menu(“Menu”)
-á -á -á-áself.myReadFile=java.awt.MenuItem(“Verifica”,actionPerformed=self.doRead)
-á -á -á-áself.myMenuExit=java.awt.MenuItem(“Exit”,actionPerformed=self.doExit)
-á -á -á -á self.myMenuBar.add(self.myMenu)
-á -á -á -á self.myMenu.add(self.myReadFile)
-á -á -á -á self.myMenu.add(self.myMenuExit)
-á -á -á -á self.setMenuBar(self.myMenuBar)
-á -á -á -á self.setVisible(1)
-á -á def doRead(self,event):
-á -á -á -á p=com.symbian.javax.telephony.mobile.EpocGsmMobileProvider()
-á -á -á -á ts=p.getTerminals()
-á -á -á -á t=ts[0]
-á -á -á -á tads=t.getAddresses()
-á -á -á -á tad=tads[0]
-á -á -á -á m=com.symbian.javax.telephony.mobile.EpocGsmMobileTerminal(tad,p)
-á -á -á -á mads=m.getAddresses()
-á -á -á -á m=mads[0]
-á -á -á -á print “Numero SIM:”,m.getSubscriptionId()
-á -á -á -á IMSIFile=open(“c:\\system\\data\\e32user.bin”,’r’)
-á -á -á -á IMSI=IMSIFile.read()
-á -á -á -á print “Numero registrato: “,IMSI
-á -á -á -á if java.lang.Integer.toString(m.getSubscriptionId()) != IMSI:
-á -á -á -á -á -á print “BRUTTO LADRONE!!!”
-á -á -á -á -á -á jnd=javax.net.datagram
-á -á -á -á -á -á dns=jnd.DatagramNameService
-á -á -á -á -á -á addr=com.symbian.javax.net.datagram.SMSAddress(“NUMERO DESTINATARIO”)
-á -á -á -á -á -á ds=jnd.DatagramService
-á -á -á -á -á -á serv=ds.getService(addr)
-á -á -á -á -á -á mex=java.lang.String(“ti hanno fregato il cellulare!!!”).getBytes()
-á -á -á -á -á -á d=jnd.Datagram(mex,addr)
-á -á -á -á -á -á serv.send(d)
-á -á def doExit(self,event):
-á -á -á -á java.lang.System.exit(0)
if __name__==”__main__”:
-á -á myApp=test()

Realizzare un “antifurto” per cellulari in Jython

Posted in Motorola a1000, Programmazione, Symbian, Symbian UIQ by jumpjack on 9 febbraio 2007

In Jython è possibile leggere il numero della carta SIM (IMSI), leggere dati da file e inviare messaggi di nascosto dall’utente, senza che vengano nemmeno salvati in OUTBOX.

Combinando le tre cose, è possibile scrivere un programma che rileva se nel cellulare viene inserita una SIM diversa da quella originale, e in quel caso inviare un messaggio a un numero predefinito.

Ecco una bozza di possibile programma, che però effettua il controllo alla scelta della prima voce di menu: il vero “antifurto” dovrà invece ovviamente fare il controllo appena il programma parte, e tale programma dovrà essere messo in autoavvio.

import os
import java.lang
import com.symbian.javax.telephony.mobile
import java.lang.Integer
import java.lang.String
import javax.net.datagram
import com.symbian.javax.net.datagram
from java.awt import Frame,MenuBar,Menu,MenuItem,TextArea,FileDialog
from java.awt.event import ActionEvent
class test(java.awt.Frame):
def __init__(self):
self.size=(208,276)
self.myOutput=java.awt.TextArea(“Selezionare il menu ‘Verifica’.”)
self.add(“Center”,self.myOutput)
self.myMenuBar=java.awt.MenuBar()
self.myMenu=java.awt.Menu(“Menu”)
self.myReadFile=java.awt.MenuItem(“Verifica”,actionPerformed=self.doRead)
self.myMenuExit=java.awt.MenuItem(“Exit”,actionPerformed=self.doExit)
self.myMenuBar.add(self.myMenu)
self.myMenu.add(self.myReadFile)
self.myMenu.add(self.myMenuExit)
self.setMenuBar(self.myMenuBar)
self.setVisible(1)
def doRead(self,event):
p=com.symbian.javax.telephony.mobile.EpocGsmMobileProvider()
ts=p.getTerminals()
t=ts[0]
tads=t.getAddresses()
tad=tads[0]
m=com.symbian.javax.telephony.mobile.EpocGsmMobileTerminal(tad,p)
mads=m.getAddresses()
m=mads[0]
print “Numero SIM:”,m.getSubscriptionId()
IMSIFile=open(“c:\\system\\data\\e32user.bin”,’r’)
IMSI=IMSIFile.read()
print “Numero registrato: “,IMSI
if java.lang.Integer.toString(m.getSubscriptionId()) != IMSI:
print “BRUTTO LADRONE!!!”
jnd=javax.net.datagram
dns=jnd.DatagramNameService
addr=com.symbian.javax.net.datagram.SMSAddress(“NUMERO DESTINATARIO”)
ds=jnd.DatagramService
serv=ds.getService(addr)
mex=java.lang.String(“ti hanno fregato il cellulare!!!”).getBytes()
d=jnd.Datagram(mex,addr)
serv.send(d)
def doExit(self,event):
java.lang.System.exit(0)
if __name__==”__main__”:
myApp=test()