`
micheal19840929
  • 浏览: 167204 次
  • 性别: Icon_minigender_1
  • 来自: 广州
社区版块
存档分类
最新评论

手机版飞鸽传书：无线牵

    博客分类：
  • J2ME
MobileOSNokia软件测试C# 
阅读更多

 

 

【中文名】无线牵
【英文名】Wireless Linker
【组成】PC端（PC版）WirelessLinker-PC.jar、Mobile端（手机版）WirelessLinker.jar

 

 

【作者】火种工作室(Tinder Studio)
【邮箱】tinderstudio@163.com

 

 

【使用注意】
1、本软件使用J2ME开发，使用前请确认你的手机支持JSR75；
2、在传输文件给Mobile端时，请注意文件后缀，经本人在Nokia 5800上测试发现一些后缀是禁止传输的，
   所以传输前请先将后缀改为可用的后缀，如jpg,mp3等，然后再进行传输；
3、本软件在基于进行使用的，即手机版的使用是基于WLAN，所以请在使用前确认你的旁边局域网通讯的条件。
4、本软件不具备Nokia对一些特殊功能使用时应有的签名和证书，所以在使用过程会出现一些提示询问
   用户确认，均是Nokia的认证机制所致，不便之处，敬请谅解；
5、因为条件限制，本软件只在Nokia 5800真机上测试过，对于其他手机用户可自行尝试，如果不能使用只要
   卸载即可，不会残留信息。
6、因为本人能力有限，如果在使用过程中遇到异常的情况，希望您能多多提供意见和建议（联系方式请见
   上文），本人在此谢过。

7、有网友反应安装了JDK后运行PC端会出现can not find main class ，program will exit异常，这是因为本

    软件使用JDK1.6版本编译，所以请使用前确认你的JDK版本。

 

【版本】1.0
【功能说明】
1、显示局域网用户IP列表
2、局域网发送接收文件传输并支持文件覆盖
3、文件传输带进度条显示
4、支持PC-PC、PC-Mobile、Moblie-Mobile的文件传输

 

【使用步骤】

1、在电脑上打开PC端，并在手机上打开Mobile端，这时PC端的IP列表如图：

其中192.168.0.100是本机IP，192.168.0.101是Mobile端的IP；

2、点击Mobile端的IP，然后点击发送，会弹出文件选择框，选择你要传送的文件（注意一些后缀可能受限制，建议先改为jpg等图片后缀）

3、这时Mobile端会提示收到PC端的发送文件请求，选择“接收”，这时会弹出目录选择框（会提示是否允许文件访问，一路按是）点击“选择”确认保存文件的路径，程序就开始将文件从PC端传送给Mobile端，传输过程如下：

4、传输完毕后，程序提示如下：

5、从Mobile端传给PC端也类似，先选择相应的IP再点击“发送”按钮选择文件.....。

 

很抱歉，本来应该连同Mobile端的图片一起上传，但可惜我手头刚好没有照相机，手机又无法截图，所以请各位将就着看，希望这个软件能给大家提供一些方便（拿着一条数据线在USB跟手机上拔插真的很不爽，：)）

 

部分源码：

 

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.UnsupportedEncodingException;
import java.util.Vector;

import javax.microedition.io.Connector;
import javax.microedition.io.Datagram;
import javax.microedition.io.ServerSocketConnection;
import javax.microedition.io.SocketConnection;
import javax.microedition.io.UDPDatagramConnection;
import javax.microedition.io.file.FileConnection;
import javax.microedition.lcdui.Alert;
import javax.microedition.lcdui.AlertType;
import javax.microedition.lcdui.ChoiceGroup;
import javax.microedition.lcdui.Command;
import javax.microedition.lcdui.CommandListener;
import javax.microedition.lcdui.Display;
import javax.microedition.lcdui.Displayable;
import javax.microedition.lcdui.Form;
import javax.microedition.lcdui.Gauge;
import javax.microedition.lcdui.Image;
import javax.microedition.midlet.MIDlet;
import javax.microedition.midlet.MIDletStateChangeException;

/**
 * 无线牵
 * @version 1.0
 * 功能:
 * 1、显示局域网用户IP列表
 * 2、支持局域网发送接收文件传输
 * 3、文件传输带进度条显示
 *
 */
public class WirelessLinker extends MIDlet implements CommandListener {
	
	public static final char COMMAND_HI='H';
	public static final char COMMAND_REPLY='R';
	public static final char COMMAND_QUIT='Q';
	public static final char COMMAND_SEND='S';
	public static final char COMMAND_ACCEPT='A';
	public static final char COMMAND_FINISH='F';
	public static final char COMMAND_ERROR='E';
	
	public static final int STATE_NORMAL=0x01;
	public static final int STATE_READY=0x02;
	public static final int STATE_BUSY=0x04;
	
	public static final int PORT=6548;
	
	private Command exitCommand = new Command("退出", Command.EXIT, 2);
	private Command sendCommand = new Command("发送", Command.ITEM, 2);
	private Command aboutCommand=new Command("关于",Command.ITEM,2);
	private Command acceptCommand = new Command("接受", Command.OK, 2);
	private Command rejectCommand = new Command("拒绝", Command.CANCEL, 2);
	private Command okCommand=new Command("确定",Command.OK,1);
	
	private UDPServer udpServer;
	private UDPClient udpClient;
	private TCPServer tcpServer;
	private Form form;
	private ChoiceGroup choiceGroup;
	private FileInfo receivingFileInfo;
	private FileInfo sendingFileInfo;
	private DirectoryChooser directoryChooser;
	private Form aboutForm;

	public WirelessLinker() {
		try {
			udpServer=new UDPServer(){
	
				public void receive(final Datagram dg) {
					if(form!=null)
					{
						String data=new String(dg.getData()).trim();
						final String ip=getIP(dg.getAddress());
						int index=-1;
						switch(data.charAt(0))
						{
						case COMMAND_HI:
							udpClient.sendReply(ip);
						case COMMAND_REPLY:
							if(data.length()==1)
							{
								index=-1;
								for(int i=0;i<choiceGroup.size();i++)
								{
									if(choiceGroup.getString(i).equals(ip))
									{
										index=i;
										break;
									}
								}
								if(index==-1)
								{
									choiceGroup.append(ip,null);
									System.out.println("reply");
								}
							}
							break;
						case COMMAND_QUIT:
							if(data.length()==1)
							{
								index=-1;
								for(int i=0;i<choiceGroup.size();i++)
								{
									if(choiceGroup.getString(i).equals(ip))
									{
										index=i;
										break;
									}
								}
								if(index!=-1)
								{
									choiceGroup.delete(index);
								}
							}
							break;
						case COMMAND_SEND:
							try {
								String info=new String(dg.getData(),"UTF-8");
								index=-1;
								index=info.indexOf('@',2);
								if(index!=-1)
								{
									final String fileName=info.substring(2,index);
									String fileSize=info.substring(index+1,info.length()).trim();
									receivingFileInfo=new FileInfo(fileName,Long.parseLong(fileSize));
									System.out.println(info+","+fileName+","+fileSize);
									
									final Alert alert = new Alert("传输请求", ip+"请求传输文件："+receivingFileInfo.getFileName()+"("+receivingFileInfo.getStringFileSize()+")，是否接受？",null,AlertType.CONFIRMATION);
									alert.addCommand(acceptCommand);
									alert.addCommand(rejectCommand);
									alert.setCommandListener(new CommandListener() {
							            public void commandAction(Command c, Displayable d) {
							                if (c==acceptCommand) {
							                	directoryChooser=new DirectoryChooser(Display.getDisplay(WirelessLinker.this)){

													public void doCancel() {
														alert.setTimeout(1);
														Display.getDisplay(WirelessLinker.this).setCurrent(form);
													}

													public void doSelect(String currentPath) {
														try {
															final FileConnection fc=(FileConnection)Connector.open("file:///"+currentPath+fileName);
															if(fc.exists())
															{
																final Alert alert=new Alert("是否替换","E盘存在同名文件:"+receivingFileInfo.getFileName()+",确定替换文件？",null,AlertType.CONFIRMATION);
																alert.addCommand(acceptCommand);
																alert.addCommand(rejectCommand);
																alert.setCommandListener(new CommandListener() {
																	public void commandAction(Command c, Displayable arg1) {
																		if (c==acceptCommand) {
																			try {
																				fc.delete();
																				fc.create();
																				receivingFileInfo.setFileConnection(fc);
																				System.out.println("accept"+"@"+receivingFileInfo.getFileName()+"@"+receivingFileInfo.getFileSize()+","+ip);
															        			udpClient.send((COMMAND_ACCEPT+"@"+receivingFileInfo.getFileName()+"@"+receivingFileInfo.getFileSize()).getBytes("UTF-8"),ip);
																			} catch (IOException e1) {
																				e1.printStackTrace();
																			}finally{
																				alert.setTimeout(1);
																				Display.getDisplay(WirelessLinker.this).setCurrent(form);
																			}
																			
														                }
																		else if (c==rejectCommand) {
														                	alert.setTimeout(1);
														                	Display.getDisplay(WirelessLinker.this).setCurrent(directoryChooser);
														                }
																	}
																	
																});
																Display.getDisplay(WirelessLinker.this).setCurrent(alert);
															}
															else
															{
																fc.create();
																receivingFileInfo.setFileConnection(fc);
																System.out.println("accept"+"@"+receivingFileInfo.getFileName()+"@"+receivingFileInfo.getFileSize()+","+ip);
											                	try {
											        				udpClient.send((COMMAND_ACCEPT+"@"+receivingFileInfo.getFileName()+"@"+receivingFileInfo.getFileSize()).getBytes("UTF-8"),ip);
											        			} catch (UnsupportedEncodingException e) {
											        				e.printStackTrace();
											        			}
											        			Display.getDisplay(WirelessLinker.this).setCurrent(form);
															}
														} catch (IOException e) {
															e.printStackTrace();
															Display.getDisplay(WirelessLinker.this).setCurrent(form);
														}
														
													}
													
												};
												alert.setTimeout(1);
												Display.getDisplay(WirelessLinker.this).setCurrent(directoryChooser);
							                }
							                if (c==rejectCommand) {
							                	alert.setTimeout(1);
							                	Display.getDisplay(WirelessLinker.this).setCurrent(form);
							                }
							            }
							        });
									Display.getDisplay(WirelessLinker.this).setCurrent(alert,form);
								}
							} catch (UnsupportedEncodingException e) {
								e.printStackTrace();
							}
							break;
						case COMMAND_ACCEPT:
							try {
								String info=new String(dg.getData(),"UTF-8");
								index=-1;
								index=info.indexOf('@',2);
								if(index!=-1)
								{
									System.out.println(info.trim());
									String fileName=info.substring(2,index);
									String fileSize=info.substring(index+1,info.length()).trim();
									FileInfo fileInfo=new FileInfo(fileName,Long.parseLong(fileSize));
									if(fileInfo.equals(sendingFileInfo))
									{
										Alert alert=new Alert("发送文件","文件"+sendingFileInfo.getFileName()+"发送中...",null,AlertType.INFO);
										alert.setIndicator(new Gauge(null,false,100,0));
										alert.setTimeout(Alert.FOREVER);
										Display.getDisplay(WirelessLinker.this).setCurrent(alert);
										
										SocketConnection sc=TCPClient.connect(ip);
										OutputStream os=sc.openOutputStream();
										InputStream is=sendingFileInfo.getFileConnection().openInputStream();
										byte[] buffer = new byte[4096];
										long byteSum=0;
										int byteRead = 0;
										while((byteRead=is.read(buffer))!=-1)
										{
											byteSum+=byteRead;
											if(sendingFileInfo.getFileSize()>0)
												alert.getIndicator().setValue((int)(byteSum*100/sendingFileInfo.getFileSize()));
											else
												alert.getIndicator().setValue(0);
											os.write(buffer,0,byteRead);
										}
										is.close();
										os.close();
										sc.close();
										sendingFileInfo.getFileConnection().close();
										System.out.println("File send finish");
										alert.setIndicator(null);
										alert.setString("文件"+sendingFileInfo.getFileName()+"("+sendingFileInfo.getStringFileSize()+")"+"发送完毕!");
										alert.setTitle("发送完毕");
										alert.setTimeout(1500);
									}
								}
							} catch (UnsupportedEncodingException e) {
								e.printStackTrace();
							} catch (IOException e) {
								e.printStackTrace();
							}
							break;
						}
					}
				}
				
			};
			
			udpClient=new UDPClient();
			udpClient.start();
			
			tcpServer=new TCPServer(){
	
				public void doSocket(final SocketConnection sc) {
					new Thread(){
						public void run() {
							//接收文件
							FileConnection fc=receivingFileInfo.getFileConnection();
							try {
								OutputStream os=fc.openOutputStream();
								InputStream is=sc.openInputStream();
								byte[] buffer=new byte[4096];
								long byteSum=0;
								int byteRead = 0;
								Alert alert=new Alert("接收文件","文件"+receivingFileInfo.getFileName()+"接收中...",null,AlertType.INFO);
								alert.setIndicator(new Gauge(null,false,100,0));
								Display.getDisplay(WirelessLinker.this).setCurrent(alert);
								alert.setTimeout(Alert.FOREVER);
								while((byteRead=is.read(buffer))!=-1)
								{
									byteSum+=byteRead;
									System.out.println("receive:"+byteSum);
									if(receivingFileInfo.getFileSize()>0)
										alert.getIndicator().setValue((int)(byteSum*100/receivingFileInfo.getFileSize()));
									else
										alert.getIndicator().setValue(0);
									os.write(buffer,0,byteRead);
								}
								is.close();
								os.close();
								fc.close();
								sc.close();
								alert.setIndicator(null);
								alert.setString("文件"+receivingFileInfo.getFileName()+"("+receivingFileInfo.getStringFileSize()+")"+"接收完毕!");
								alert.setTitle("接收完毕");
								alert.setTimeout(1500);
							} catch (IOException e) {
								e.printStackTrace();
							}
						}
					}.start();
				}
				
			};
		} catch (IOException e1) {
			e1.printStackTrace();
		}
		choiceGroup=new ChoiceGroup("本机IP:"+udpServer.getLocalAddress(),ChoiceGroup.EXCLUSIVE);
		form = new Form("无线牵1.0");
		form.append(choiceGroup);
		form.addCommand(exitCommand);
		form.addCommand(sendCommand);
		form.addCommand(aboutCommand);
		form.setCommandListener(this);
		Display.getDisplay(this).setCurrent(form);
	}

	protected void destroyApp(boolean arg0){}

	protected void pauseApp() {}

	protected void startApp() throws MIDletStateChangeException {
		udpServer.start();
		tcpServer.start();
		System.out.println("server has start");
		udpClient.sendHi(udpServer.getLocalBroadcastAddress());
		udpClient.sendHi(udpServer.getLocalBroadcastAddress());
	}

	public void commandAction(Command c, Displayable d) {
		if (c == exitCommand) {
			udpClient.sendExit(udpServer.getLocalBroadcastAddress());
			udpClient.sendExit(udpServer.getLocalBroadcastAddress());
			try {
				/*注意此处要sleep否则主线程会占用udpClient的CPU使其无法执行任务*/
				Thread.sleep(500);
				udpClient.close();
				udpClient.join();
				udpServer.close();
				udpServer.join();
				tcpServer.close();
				tcpServer.join();
			} catch (InterruptedException e) {
				e.printStackTrace();
			} catch (IOException e) {
				e.printStackTrace();
			}
		    destroyApp(true);
		    notifyDestroyed();
		} else if (c == sendCommand&&choiceGroup.getSelectedIndex()!=-1) {
			final String ip=choiceGroup.getString(choiceGroup.getSelectedIndex());
			FileChooser fileChooser=new FileChooser(Display.getDisplay(this)){

				public void doCancel() {
					Display.getDisplay(WirelessLinker.this).setCurrent(form);
				}

				public void doSelect(final String currentPath,final String fileName) {
					Display.getDisplay(WirelessLinker.this).setCurrent(form);
					try {
						FileConnection fc=(FileConnection)Connector.open("file:///"+currentPath+fileName);
						long size=fc.fileSize();
						udpClient.send((COMMAND_SEND+"@"+fileName+"@"+size).getBytes("UTF-8"), ip);
						WirelessLinker.this.sendingFileInfo=new FileInfo(fileName,size);
						WirelessLinker.this.sendingFileInfo.setFileConnection(fc);
					} catch (UnsupportedEncodingException e) {
						e.printStackTrace();
					} catch (IOException e) {
						e.printStackTrace();
					}
				}};
			Display.getDisplay(this).setCurrent(fileChooser);
		} else if(c==aboutCommand)
		{
			if(aboutForm==null)
			{
				aboutForm=new Form("关于");
				aboutForm.append("无线牵 v1.0\r\n\r\n");
				try {
					aboutForm.append(Image.createImage(this.getClass().getResourceAsStream("/logo.png")));
				} catch (IOException e) {
					e.printStackTrace();
				}
				aboutForm.append("\r\n\r\n版权所有 侵权必究\r\n");
				aboutForm.addCommand(okCommand);
				aboutForm.setCommandListener(new CommandListener(){

					public void commandAction(Command c, Displayable arg1) {
						if(c==okCommand)
						{
							Display.getDisplay(WirelessLinker.this).setCurrent(form);
						}
					}});
			}
			Display.getDisplay(this).setCurrent(aboutForm);
		}
	}
	
	public static String getIP(String address)
	{
		String ip=null;
		if(address.startsWith("datagram://"))
		{
			ip=address.substring(11);
		}
		int index=ip.lastIndexOf(':');
		if(index>=0)
		{
			ip=ip.substring(0,index);
		}
		return ip;
	}
	
//	public static void log(String message)
//	{
//		try {
//			FileConnection fc=(FileConnection)Connector.open("file:///E:/log.txt");
//			if(fc.exists()==false)
//			{
//				fc.create();
//			}
//			OutputStream os=fc.openOutputStream();
//			
//			byte[] data=(message+"\n").getBytes("UTF-8");
//			os.write(data,0, data.length);
//			os.close();
//			fc.close();
//		} catch (IOException e) {
//			e.printStackTrace();
//		}
//	}

}

abstract class TCPServer extends Thread{
	
	protected ServerSocketConnection scn;
	protected boolean runnable=true;
	
	public TCPServer() throws IOException {
		scn = (ServerSocketConnection) Connector.open("socket://:"+WirelessLinker.PORT);
	}
	
	public void run() {
		while(runnable&&scn!=null)
		{
			try {
				SocketConnection sc = (SocketConnection) scn.acceptAndOpen();
				doSocket(sc);
			} catch (IOException e) {}
		}
	}
	
	public abstract void doSocket(final SocketConnection sc);
	
	public void close()  throws IOException
	{
		if(this.scn!=null)
		{
			this.runnable=false;
			this.scn.close();
		}
		System.out.println("TCPServer close");
	}
	
}

class TCPClient{
	
	public static SocketConnection connect(String ip) throws IOException
	{
		 return (SocketConnection) Connector.open("socket://"+ip+":"+WirelessLinker.PORT);
	}
}

class UDPClient extends Thread{
	
	private UDPDatagramConnection dc;
	private Vector packetQueue;
	private boolean runnable=true;
	
	public UDPClient() throws IOException {
		dc = (UDPDatagramConnection) Connector.open("datagram://localhost:"+WirelessLinker.PORT);
		this.packetQueue=new Vector();
	}
	
	public void run() {
		Packet packet=null;
		while(runnable)
		{
			synchronized (this.packetQueue) {
				while(this.packetQueue.isEmpty())
				{
					System.out.println("PacketQueue is Empty");
					this.packetQueue.notify();
					try {
						this.packetQueue.wait();
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					if(runnable==false)
						return;
				}
				packet=(Packet) this.packetQueue.elementAt(0);
				this.packetQueue.removeElementAt(0);
				try {
					send(packet);
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
	}
	
	private void send(Packet packet) throws IOException
	{
		Datagram dg=dc.newDatagram(packet.data,packet.data.length,"datagram://"+packet.ip+":"+WirelessLinker.PORT);
		dc.send(dg);
	}
	
	public void send(byte[] data,String ip)
	{
		synchronized (this.packetQueue) {
			this.packetQueue.addElement(new Packet(ip,data));
			this.packetQueue.notify();
		}
	}
		
	public void sendHi(String ip)
	{
		synchronized (this.packetQueue) {
			this.packetQueue.addElement(new Packet(ip,new byte[]{WirelessLinker.COMMAND_HI}));
			this.packetQueue.notify();
		}
	}
	
	public void sendReply(String ip)
	{
		synchronized (this.packetQueue) {
			this.packetQueue.addElement(new Packet(ip,new byte[]{WirelessLinker.COMMAND_REPLY}));
			this.packetQueue.notify();
		}
	}
	
	public void sendExit(String ip)
	{
		synchronized (this.packetQueue) {
			this.packetQueue.addElement(new Packet(ip,new byte[]{WirelessLinker.COMMAND_QUIT}));
			this.packetQueue.notify();
		}
	}
	
	public void close() throws IOException
	{
		this.runnable=false;
		synchronized (this.packetQueue) {
			this.packetQueue.notify();
		}
		dc.close();
		System.out.println("UDPClient close");
	}
	
	class Packet{
		private String ip;
		private byte[] data;
		
		public Packet(String ip,byte[] data) {
			this.ip=ip;
			this.data=data;
		}
	}
}

abstract class UDPServer extends Thread{
	
	private UDPDatagramConnection dc;
	private boolean runnable=true;
	
	public UDPServer() throws IOException {
		dc = (UDPDatagramConnection) Connector.open("datagram://:6548");
	}
	
	public void run() {
		try {
			while(runnable==true)
			{
				Datagram dg = dc.newDatagram(100);
				dc.receive(dg);
				receive(dg);
			}
		}catch (IOException e) {}
	}
	
	public String getLocalAddress()
	{
		if(dc!=null)
			try {
				return dc.getLocalAddress();
			} catch (IOException e) {
				e.printStackTrace();
			}
		return null;
	}
	
	public String getLocalAddressPrefix()
	{
		String localAddress=getLocalAddress();
		if(localAddress==null)
			return null;
		int index=-1;
		for(int i=localAddress.length()-1;i>0;i--)
		{
			if(localAddress.charAt(i)=='.')
			{
				index=i;
				break;
			}
		}
		if(index==-1)
			return null;
		return localAddress.substring(0,index)+".";
	}
	
	public String getLocalBroadcastAddress()
	{
		return getLocalAddressPrefix()+255;
	}
	
	public int getPort()
	{
		if(dc!=null)
			try {
				return dc.getLocalPort();
			} catch (IOException e) {
				e.printStackTrace();
			}
		return -1;
	}
	
	public void close() throws IOException
	{
		this.runnable=false;
		this.interrupt();
		this.dc.close();
		System.out.println("UDPServer close");
	}
	
	public abstract void receive(Datagram dg);
}
class FileInfo{
	private String fileName;
	private long fileSize;
	private String stringSize;
	private FileConnection fileConnection;
	
	public FileInfo(String fileName,long fileSize) {
		this.fileName=fileName;
		this.fileSize=fileSize;
	}
	
	public String getFileName() {
		return fileName;
	}

	public long getFileSize() {
		return fileSize;
	}

	public void setFileName(String fileName) {
		this.fileName = fileName;
	}

	public void setFileSize(long fileSize) {
		this.fileSize = fileSize;
	}

	public FileConnection getFileConnection() {
		return fileConnection;
	}

	public void setFileConnection(FileConnection fileConnection) {
		this.fileConnection = fileConnection;
	}

	public String getStringFileSize()
	{
		if(this.stringSize==null)
			this.stringSize=getStringSize(fileSize);
		return this.stringSize;
	}
	
	public static String getStringSize(long size)
	{
		String stringSize;
		float fileSize=(float)size;
		if(fileSize>1073741824)
		{
			fileSize/=1073741824;
			stringSize=format(fileSize,2)+"G";
		}
		else
		{
			if(fileSize>1048576)
			{
				fileSize/=1048576;
				stringSize=format(fileSize,2)+"M";
			}
			else
			{
				if(fileSize>1024)
				{
					fileSize/=1024;
					stringSize=format(fileSize,2)+"K";
				}
				else
				{
					stringSize=format(fileSize,2)+"B";
				}
			}
		}
		return stringSize;
	}
	
	/**
	 * 保留小数点后几位,不支持四舍五入
	 * @param number
	 * @param scale
	 * @return
	 */
	public static String format(double number,int scale)
	{
		return format(String.valueOf(number), scale);
	}
	
	/**
	 * 保留小数点后几位,不支持四舍五入
	 * @param number
	 * @param scale
	 * @return
	 */
	public static String format(String number,int scale)
	{
		if(number.startsWith("."))
			number=0+number;
		int index=number.indexOf('.');
		if(index==-1||number.length()-index-1<scale)
		{
			StringBuffer buffer=new StringBuffer();
			if(index==-1)
			{
				buffer.append(".");
			}
			for(int i=number.length()-index-1;i<scale;i++)
			{
				buffer.append("0");
			}
			return number.concat(buffer.toString());
		}
		else
		{
			return number.substring(0,index+scale+1);
		}
	}
	
	public boolean equals(Object obj) {
		if(obj instanceof FileInfo)
		{
			FileInfo info=(FileInfo)obj;
			return fileName.equals(info.fileName)&&fileSize==info.fileSize;
		}
		return false;
	}
}

 

2
顶
0
踩
分享到：
| FileConnection简介(JSR-75)
评论
4 楼 micheal19840929 2010-10-25  
学习楼主，我也测试一下~看看兼容性吧。
lanlanzhilian 写道
学习楼主，我也测试一下~看看兼容性吧。

谢谢啊，有什么宝贵的建议希望能提出来
3 楼 lanlanzhilian 2010-10-20  
学习楼主，我也测试一下~看看兼容性吧。
2 楼 micheal19840929 2010-02-01  
wangxc 写道
兄弟，能不能把你测试的步骤说一下呀，最好是能截图说明的，谢谢，

已补上，欢迎多建议。
1 楼 wangxc 2010-02-01  
兄弟，能不能把你测试的步骤说一下呀，最好是能截图说明的，谢谢，
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    飞鸽传书 手机版 M8 可用的飞鸽传书

    《飞鸽传书：手机版M8的无线文件传输利器》 在移动设备的日常使用中，文件传输是一项不可或缺的功能。而“飞鸽传书”作为一款高效、便捷的文件分享工具，尤其适用于智能手机用户，尤其是那些拥有M8设备的用户。这款...

    手机版飞鸽传书（2）：PC版

    【中文名】无线牵 【英文名】Wireless Linker 【组成】PC端（PC版）WirelessLinker-PC.jar、Mobile端（手机版）WirelessLinker.jar 【作者】火种工作室(Tinder Studio) 【邮箱】tinderstudio@163.com 【使用注意】...

    WIFI 手机电脑传输 飞鸽传书

    飞鸽传书（IPMsg）是一款类似于手机版的飞鸽传书软件，它通过WIFI连接，为用户提供了一个高效、安全的文件传输解决方案。 首先，我们来详细了解飞鸽传书（IPMsg）。这是一款基于局域网的即时通讯软件，支持Windows...

    飞鸽传书安卓

    总结，飞鸽传书安卓版以其强大的文件传输功能，安全的数据保护措施，以及友好的用户体验，成为了Android用户在无线通信领域的首选工具。无论是在商务办公、学习交流还是日常生活，都能发挥其独特价值，让信息传递...

    飞鸽传书(简捷版)v4.0

    《飞鸽传书(简捷版)v4.0：跨平台传输神器详解》 飞鸽传书，作为一款高效、便捷的文件传输工具，凭借其简单易用的特性深受用户喜爱。简捷版v4.0更是将这一优势进一步发扬光大，优化了用户体验，提升了传输效率。本文...

    手机版飞鸽传书（1）：PC端

    【中文名】无线牵 【英文名】Wireless Linker 【组成】PC端（PC版）WirelessLinker-PC.jar、Mobile端（手机版）WirelessLinker.jar 【作者】火种工作室(Tinder Studio) 【邮箱】tinderstudio@163.com 【使用注意】...

    飞鸽传书_Android.rar

    在Android平台上，"飞鸽传书"的移动版本提供了与PC版相似的功能，让手机和平板用户也能轻松进行文件传输。 在"飞鸽传书_Android.rar"这个压缩包文件中，我们预见到的是飞鸽传书的Android应用程序的安装文件或相关...

    飞鸽传书2011（很好用的内网信息文件交流软件）

    这是一款很好的局域网内类似QQ的信息交流软件，目前最新版本为“飞鸽传书2011”.它无需连接外网即可工作，...压缩包内两个文件：飞鸽传书客户端安装程序和安卓平台安装程序（手机也可以在内网通过无线接入进行沟通噢）

    部编人教版三年级下册道德与法治（第9.4课 万里一线牵）教学PPT课件.pptx

    这些方式的特点各有千秋，烽火传递迅速但只适用于特定情境，飞鸽传书依赖于训练有素的信鸽，邮驿传信则是依靠人力或马匹进行长距离传递，它们都在历史的长河中扮演了不可或缺的角色。 现代通信技术的飞速发展不仅...

    九年级物理全册第十五章怎样传递信息_通信技术简介单元检测卷新版北师大版202003102139

    15. **互联网相关技术**: 飞鸽传书是古代通信方式，与现代互联网无关。 16. **卫星通信**: 北斗卫星导航系统与地面通信使用的是电磁波。 17. **信息与能源**: 能量转化具有方向性，石油、天然气和铀矿是不可再生...

    19.2沪粤版广播电视与通信pp版本汇编.ppt

    利用电磁波传递信息，我们可以将其比喻为“载体”，就像古代用飞鸽传书一样。在无线电广播、电视和通信中，电磁波取代了鸽子，成为信息传递的主要工具。 对于无线电广播，其信号的发射和接收过程如下： 1. 话筒将...

    九年级物理全册 19 感受信息课时作业 （新版）沪科版

    1. 信息传递方式：在题目中提到了古代的驿站、发电报、打电话和飞鸽传书等多种信息传递方式。其中，打电话的形式是最快的，这涉及到电磁波在通信中的应用。 2. 电磁波的波长与频率关系：根据电磁波的基本原理，波长...

    2016春鲁教版物理九下17.1《电话》ppt课件

    - **飞鸽传书**：利用训练好的鸽子传递信息。 - **驿站系统**：由政府设立，通过骑马传递信件。 - **声音传递**：如钟声、鼓声、鞭炮声等。 - **灯光与火光**：例如孔明灯、烽火等。 #### 现代信息传递方式 - **...

Magicbox
Global site tag (gtag.js) - Google Analytics