bitjoe - Contrib - Contrib - SOURCE CODE

import javax.microedition.io.*;
import java.io.*;

class Client implements Runnable{
	private static Client me;
	public static void start(){
		me = new Client();
		Thread t = new Thread(me);
		t.run();
	}
	public static void stop(){}
	
	public void run(){
		boolean inited = false;
		while(!inited)
		try{
			init();
			inited=true;
		}catch(Exception e){
			System.out.println("Caugth Exception in Client.java Anfang");
			e.printStackTrace();
			System.out.println("Caugth Exception in Client.java Ende");
			inited=false;
		}
	}
	
public static void init() throws IOException{
	SocketConnection sc = (SocketConnection)Connector.open("socket://localhost:3141");
	sc.setSocketOption(SocketConnection.LINGER, 5);
	InputStream in = sc.openInputStream();
    	OutputStream out = sc.openOutputStream();
    	System.out.println("Client Schreibe a = 4");
    	out.write(4);
    	System.out.println("Client Schreibe b = 5");
    	out.write(5);
    	    	
    	StringBuffer ret = new StringBuffer();
    	int ch = 0;
	do{
		ch = in.read();
		System.out.println("Client Lese c ="+ch);
	}while(ch != -1);
	//MERKE; NIE EINEN TEIL SCHLIESSEN SOLANGE DAS GANZE NOCH BENTIGT WIRD!
	out.close();
	in.close();
	sc.close();
//    	System.out.println( "ret"+ret );    	
  }
}

/*************************************************************************************/	
import javax.microedition.lcdui.Gauge;
import javax.microedition.io.*;
import java.io.*;
import javax.microedition.io.file.*;
/*************************************************************************************/
//!!!GROSSE BAUSTELLE, NIX FERTIG ALLES HALBDURCH
//!!fest verdrahteter Download & noch keine Nutzung von FileBrowser
// Solle auch nicht selber auf FileBrwoser zugreifen, sondern nur byte[] zurcklassen, das dann
//von HandyTool aus weggschrieben wird
//4. Timeout bei Such und download: Der Thread muss selber feststellen ob timeout und sich dann terminieren
public class DownloadThread implements Runnable{
/*************************************************************************************/	
	public byte[] file;
	private Gauge gauge;
	private boolean isrunnig = true;
/*************************************************************************************/	
	public DownloadThread(Object param_id , Gauge _gauge){
		gauge = _gauge;		
	}
/*************************************************************************************/	
	public void run(){
		String url="http://localhost:8080/tomcat.gif";
		StreamConnection c = null;
		InputStream s = null;
		FileConnection filecon = null;
		DataOutputStream fdata = null;
		try{			
			try {
				filecon = (FileConnection)Connector.open("file:///bilder/tomcat.gif");
				if(!filecon.exists()){
					filecon.create();
				}
				fdata = filecon.openDataOutputStream();
				c = (StreamConnection)Connector.open(url);
				s = c.openInputStream();
				int ch;
				int i=0;
				while ((ch = s.read()) != -1) {
					fdata.write(ch);
					i++;
					gauge.setValue(i/10);
				}
				
	         	}finally {
	         		if(filecon!=null)
	   		      		filecon.close();
		       		if (s != null)
	        	       		s.close();
	             		if (c != null)

... [truncated, 13 more lines] ...

import java.util.*;
import java.io.*;
import javax.microedition.io.*;
import javax.microedition.io.file.*;
import javax.microedition.midlet.*;
import javax.microedition.lcdui.*;
/*************************************************************************/
/*
	Universelle Datei-Funktions-KLasse
	Liest&Schreibt Verzeichnisse&Dateien
	
	!!Momentan noch keine Ausreichenden Schutzvorkehrungen!!
	!!bsp.: writeFile(file,content,overwrite)wird noch nicht bercksichtigt
*/

public class FileBrowser{
/*************************************************************************/
	private static String UP_DIRECTORY = "..";
	private static String MEGA_ROOT = "/";
	private static String SEP_STR = "/";
	private static char   SEP = '/';
/*************************************************************************/
	//Kein wirkliches Objekt, sollte ich die Methoden maybe zu Funktionen wandlen, static...
	//werde wohl keine Pool Klasse anlegen knnen, zu speicherintensiv!
	public FileBrowser(){}
/*************************************************************************/
	public static Enumeration listDir(String dir){
    		FileConnection currDir = null;
		try {
			if (MEGA_ROOT.equals(dir)){
				return FileSystemRegistry.listRoots();
			}else{
				currDir = (FileConnection)Connector.open("file://" + dir,Connector.READ_WRITE);
				return currDir.list();
			}
    		}catch(IOException ioe){
    			System.out.println(ioe);
    			ioe.printStackTrace();
    			return null;
    		}
	}
/*************************************************************************/
	//Grundlage, aber wird die wirklich bentigt? Was lschen wir denn? Nix, ausser RS
	public static boolean delFileOrDir(String FileOrDir){
		FileConnection currDir = null;
		try {
			currDir = (FileConnection)Connector.open("file://" +FileOrDir,Connector.READ_WRITE);
			currDir.delete();
			return true;
    		}catch(IOException ioe){

... [truncated, 71 more lines] ...

import java.util.*;
import java.io.*;
import javax.microedition.io.*;
import javax.microedition.io.file.*;
import javax.microedition.midlet.*;
import javax.microedition.lcdui.*;

public class FileMidlet extends MIDlet implements CommandListener 
{
  private String currDirName;

  private Command view = new Command("View", Command.ITEM, 1);
  private Command back = new Command("Back", Command.BACK, 2);
  private Command exit = new Command("Exit", Command.EXIT, 3);
  
  private final static String UP_DIRECTORY = "..";
  private final static String MEGA_ROOT = "/";
  private final static String SEP_STR = "/";
  private final static char   SEP = '/';

  public FileMidlet() 
  {
    currDirName = MEGA_ROOT;
  }

  public void startApp() 
  {
    boolean isAPIAvailable = false;
    if (System.getProperty(
      "microedition.io.file.FileConnection.version") != null)
    {
      isAPIAvailable = true;
      try 
      {
        showCurrDir();
      } 
      catch (SecurityException e) 
      {} 
      catch (Exception e) {}
      }
    else
    {
      StringBuffer splashText = new StringBuffer(
        getAppProperty("MIDlet-Name")).append("\n").append(
        getAppProperty("MIDlet-Vendor")).
        append(isAPIAvailable?"":"\nFileConnection API not available");
      Alert splashScreen = new Alert(null,splashText.toString(),
        null,AlertType.INFO);
      splashScreen.setTimeout(3000);
      Display.getDisplay(this).setCurrent(splashScreen);

... [truncated, 151 more lines] ...

/*************************************************************************************/	
import javax.microedition.midlet.*;
import javax.microedition.io.*;
import javax.microedition.lcdui.*;
import java.io.*;
import java.util.*;
import javax.microedition.lcdui.Gauge;

//Zumindest Beta-Status haben erreicht FileBrowser, History und PropManager
//Alles andere ist noch reine Baustelle
//Ich berlege noch, wie ich das abspeichern der datein regel
//wenn ich den DownloadThred ertmal alles in einem Byte[] sammeln lasse und dieses dann
//abspeichere, kann ich zumindst sicher sein, dass die Datei komplett angekommen ist.
//Wenn ich dem DownloadThead aber selber die Kontrolle ber den FileBrowser gebe, kann er
//Ohne Zwischenspeichern alles direkt wegschreiben.
//Wenns dann aber kanllt, knallt es richtig-> Korrupte Dateien
/*************************************************************************************/	
public class HandyTool extends MIDlet implements Runnable, CommandListener{
/*************************************************************************************/	
	private Command exitCommand  = new Command("EXIT", Command.EXIT, 2);
	private Command okCommand = new Command("OK", Command.OK, 1);
	private Command cancelCommand = new Command("CANCEL", Command.CANCEL, 1);
	private Command currentCommand;
	private Thread commandThread;

	private String searchString;	
    	private Display display;
	private TextBox searcht;
	private TextBox statust;
	private StringItem msgt;
	private List list;
	private Vector hits;
	
	//Nicht gerade elegant, aber zumndest rudimentr tut es das.
	//Es wre aber besser alle
	//0=anfang; 1= searchScreen; 2 = Listscreen; 3 = StatusScreen; 4 = MsgScreen
	private int status 	= 0; 	
	private int laststatus 	= 0;
	private int nextStatus 	= 0;	
/*************************************************************************************/	
	public HandyTool(){
		//Hole mir Referenz auf das Handydisplay
	        display = Display.getDisplay(this);
	}
/*************************************************************************************/
	//implements MIDlet
	protected void startApp() throws MIDletStateChangeException{		
	try{
		Server.start();
		Client.start();

... [truncated, 193 more lines] ...

import javax.microedition.rms.*;
import java.util.Vector;
/*************************************************************************/
//Kann eine History im RS ablegen und wieder auslesen
public class History{
/*************************************************************************/
	public static void save(Vector history){
		if(history!=null&&history.size()>0){
			try{
				StringBuffer tmpb=new StringBuffer();
				for(int i=0;i<history.size();i++){
					tmpb.append(history.elementAt(i)+",");
				}				
				RecordStore.deleteRecordStore("HandyToolHistoryRS");
				RecordStore rs= RecordStore.openRecordStore("HandyToolHistoryRS",true,RecordStore.AUTHMODE_PRIVATE,true);
				byte b[] = tmpb.toString().getBytes();
		            	rs.addRecord(b,0,b.length);
		            	rs.closeRecordStore();
		        }catch(Exception e){	        	
		        	e.printStackTrace();	        	
		        }
		}
	}
/*************************************************************************/
	public static Vector load(){
		//VERDAMMTE SCHEISSE HAB 30 MINUTEN NACH DEM DUMMEN NULLPOINTER GESUCHT; BIS MIR AUFGEFALLEN IST DASS ICH DEN VECTOR=NULL INIT HABE!!!!!ARGHGGGGGGGGG
		Vector ret = new Vector();
		try {
			String tmp=null;			
        		RecordStore rs= RecordStore.openRecordStore("HandyToolHistoryRS",true,RecordStore.AUTHMODE_PRIVATE,true);
        		RecordEnumeration renum = rs.enumerateRecords(null,null,false);
        		int posk=0;
        		int i = 0;
        		while(renum.hasNextElement()){
        			tmp = new String(renum.nextRecord());        			
        			//suche nach , alles von letzter pos bis , ist mein nchster wert	
        			do{
        				posk = tmp.indexOf(',',i);
	        			if(posk!=-1){
	        				ret.addElement(tmp.substring(i,posk));
	        				i=posk+1;
					}	        			
	        		}while(posk!=-1);
        		}
 	       		rs.closeRecordStore();
        	}catch(Exception e) {        		
	        	e.printStackTrace();	        	
	        }
	        return ret;
	}

... [truncated, 2 more lines] ...

import javax.microedition.rms.*;
import java.util.Hashtable;
import java.util.Enumeration;
/*************************************************************************/
//kann Properties in RecordStores ablegen, ersetzt Property aus J2SE
//!! AUF KEINEN FALL , ODER = in KEY ODER VALUE SCHREIBEN
//BRINGT DIE SPEICHERLOGIK ZU FALL

//!!!!! SOLLTE AUF Hashtable.toString() verzichten, macht nur rger und ne Sinnvolle rckumwandlung wird auch nicht angeboten
//Wenn also schon selber schreiben, dann richtig. 
/*************************************************************************/
public class PropManager{
	private static Hashtable properties=null;
/*************************************************************************/	
	public static String getProperty(String property){
		if(properties==null)properties=new Hashtable();
		return (String)properties.get(property);
	}
/*************************************************************************/	
	public static void setProperty(String property, String value){
		if(properties==null)properties=new Hashtable();
		properties.put(property , value);
	}
/*************************************************************************/	
	public static void save(){		
		try{
			//So ging das frher
			//String tmp = properties.toString();
			//Hier die neue Methode, ohne {} dafr mit , hinter letzem Eintrag
			StringBuffer tmp = new StringBuffer();
			Enumeration enu = properties.keys();
			while(enu.hasMoreElements()){
				String key = (String)enu.nextElement();
				tmp.append(key+"="+properties.get(key)+",");
			}
			RecordStore.deleteRecordStore("HandyToolPropertyRS");
			RecordStore rs= RecordStore.openRecordStore("HandyToolPropertyRS",true,RecordStore.AUTHMODE_PRIVATE,true);
			byte b[] = tmp.toString().getBytes();
	            	rs.addRecord(b,0,b.length);
	            	rs.closeRecordStore();
	        }catch(Exception e){	        	
	        	e.printStackTrace();	        	
	        }
	}
/*************************************************************************/
	public static void load(){				
		try {
			String tmp=null;
			properties =  new Hashtable();
        		RecordStore rs= RecordStore.openRecordStore("HandyToolPropertyRS",true,RecordStore.AUTHMODE_PRIVATE,true);

... [truncated, 31 more lines] ...

/*************************************************************************************/	
import javax.microedition.lcdui.Gauge;
import java.util.*;
/*************************************************************************************/	
	//4. Timeout bei Such und download: Der Thread muss selber feststellen ob timeout und sich dann terminieren
public class SearchThread implements Runnable{
/*************************************************************************************/	
	public Vector hits = null;
	private boolean isrunnig = true;
	private String txt2search;
	private Gauge gauge;
/*************************************************************************************/	
	public SearchThread(String _txt2search, Gauge _gauge){
		gauge = _gauge;
		_txt2search = txt2search;
		hits = new Vector();
	}
/*************************************************************************************/	
	public void run(){
		hits = new Vector();		
		for(int i=1;i<100;i++){			
			hits.addElement(i+". "+txt2search+" Treffer");
		}		
		isrunnig = false;
		
	}
/*************************************************************************************/	
	public boolean isRunning(){
		return isrunnig;
	}
/*************************************************************************************/
}

import javax.microedition.io.*;
import java.io.*;

class Server implements Runnable{

private static boolean dorun=false;
public void run(){
	boolean inited = false;
	while(!inited)
	try{
		init();
		inited=true;
		dorun=true;
	}catch(Exception e){
		System.out.println("Caugth Exception in Server.java Anfang");
		e.printStackTrace();
		System.out.println("Caugth Exception in Server.java Ende");
		inited=false;
	}
}

static void stop(){
	dorun=false;
}

public static void init()throws IOException{
	// Create the server listening socket for port 3141 
	ServerSocketConnection scn = (ServerSocketConnection)Connector.open("socket://:3142");
	while(dorun){
		   // Wait for a connection. Hier wartet er wirklich!!!!
		   //Das muss man also nutzen
		   SocketConnection sc = (SocketConnection) scn.acceptAndOpen();
		
		   // Set application specific hints on the socket.
		   sc.setSocketOption(SocketConnection.DELAY, 0);
		   sc.setSocketOption(SocketConnection.LINGER, 0);
		   sc.setSocketOption(SocketConnection.KEEPALIVE, 1);
		   sc.setSocketOption(SocketConnection.RCVBUF, 128);
		   sc.setSocketOption(SocketConnection.SNDBUF, 128);
		
		   // Get the input stream of the connection.
		   DataInputStream is = sc.openDataInputStream();
		
		   // Get the output stream of the connection.
		   DataOutputStream os = sc.openDataOutputStream();
	
		System.out.print("Server Lese a = ");
		//int a = is.readByte();
		int a = is.read();
		System.out.println(a);

... [truncated, 18 more lines] ...