Added demo app

Author: shannah

.gitignore

@@ -0,0 +1,4 @@
+/build/
+/CN1SocketsDemo/nbproject/private/
+/CN1SocketsDemo/build/
+/CN1SocketsDemo/dist/

CN1SocketsDemo/CodeNameOneBuildClient.jar

@@ -0,0 +1,34 @@
+#
+#Mon Nov 17 10:20:04 PST 2014
+codename1.vendor=CodenameOne
+codename1.displayName=CN1SocketsDemo
+codename1.icon=icon.png
+codename1.languageLevel=5
+codename1.ios.debug.certificatePassword=
+codename1.arg.vserv.transition=3000
+codename1.secondaryTitle=CN1SocketsDemo
+codename1.version=1.0
+package=generated
+codename1.mainName=SocketsDemo
+codename1.ios.certificatePassword=
+codename1.ios.release.provision=
+codename1.rim.signtoolDb=
+libVersion=80
+codename1.ios.release.certificatePassword=
+codename1.ios.certificate=
+userClass=src/userclasses/StateMachine.java
+codename1.j2me.nativeTheme=nbproject/nativej2me.res
+codename1.ios.appid=Q5GHSKAL2F.ca.weblite.codename1.sockets.demo
+codename1.android.keystorePassword=
+codename1.ios.release.certificate=
+codename1.rim.signtoolCsk=
+codename1.ios.debug.certificate=
+mainForm=Main
+baseClass=src/generated/StateMachineBase.java
+codename1.android.keystore=
+guiResource=theme.res
+codename1.android.keystoreAlias=
+codename1.rim.certificatePassword=
+codename1.ios.debug.provision=
+codename1.ios.provision=
+codename1.packageName=ca.weblite.codename1.sockets.demo

CN1SocketsDemo/JavaSE.jar

@@ -0,0 +1,248 @@
+package ca.weblite.codename1.net.impl;
+
+
+import java.net.Socket;
+public class NativeSocketImpl {
+    private Socket socket;
+    private byte[] receiveBuffer, sendBuffer;
+    private Throwable lastError;
+    private int bufferId;
+    private String host;
+    private int port;
+    
+    public void setBufferId(int bufferId){
+        this.bufferId = bufferId;
+    }
+    
+    public int getBufferId(){
+        return bufferId;
+    }
+
+    
+    
+    
+    public int read() {
+        try {
+            return socket.getInputStream().read();
+        } catch ( Throwable t){
+            lastError = t;
+            return -2;
+        }
+    }
+
+    public long skip( long n) {
+        try {
+            return socket.getInputStream().skip(n);
+        } catch (Throwable t){
+            lastError = t;
+            return -2;
+        }
+    }
+
+    public int available() {
+        try {
+            return socket.getInputStream().available();
+        } catch ( Throwable t){
+            lastError = t;
+            return -2;
+        }
+    }
+
+    public boolean markSupported() {
+        try {
+            return socket.getInputStream().markSupported();
+        } catch ( Throwable t ){
+            lastError = t;
+            return false;
+        }
+        
+    }
+
+   
+
+    public boolean setReceiveBufferSize( int size) {
+        try {
+            socket.setReceiveBufferSize(size);
+            receiveBuffer = new byte[size];
+            return true;
+        } catch ( Throwable t ){
+            lastError = t;
+            return false;
+        }
+    }
+
+    public boolean write( int b) {
+        try {
+            socket.getOutputStream().write(b);
+            return true;
+        } catch ( Throwable t){
+            lastError = t;
+            return false;
+        }
+    }
+
+    public boolean setSendBufferSize( int size) {
+        try {
+            socket.setSendBufferSize(size);
+            sendBuffer = new byte[size];
+            return true;
+        } catch ( Throwable t){
+            lastError = t;
+            return false;
+        }
+    }
+
+    public boolean setKeepAlive( boolean on) {
+        try {
+            socket.setKeepAlive(on);
+            return true;
+        } catch ( Throwable t){
+            lastError = t;
+            return false;
+        }
+    }
+
+    public boolean isInputShutdown() {
+        return socket.isInputShutdown();
+    }
+
+    public boolean isOutputShutdown() {
+        return socket.isOutputShutdown();
+    }
+
+    public String getErrorMessage() {
+        return lastError.getMessage();
+    }
+
+    public boolean closeOutputStream() {
+        try {
+            socket.getOutputStream().close();
+            return true;
+        } catch ( Throwable t){
+            lastError = t;
+            return false;
+        }
+    }
+
+    public int readBuf(int len) {
+        byte[] buf = ca.weblite.codename1.net.Socket.getBuffer(bufferId);
+        try {
+            return socket.getInputStream().read(buf, 0, len);
+            
+        } catch ( Throwable t){
+            lastError = t;
+            return -2;
+        }
+    }
+
+    public boolean closeInputStream() {
+        try {
+            socket.getInputStream().close();
+            ca.weblite.codename1.net.Socket.deleteBuffer(bufferId);
+            return true;
+        } catch ( Throwable t ){
+            lastError = t;
+            return false;
+        }
+    }
+
+    public int getErrorCode() {
+        return 0;
+    }
+
+    public boolean createSocket(String host, int port) {
+        this.host = host;
+        this.port = port;
+        return true;
+        
+    }
+
+    public boolean connectSocket(int timeout){
+        try {
+            socket = new Socket(host, port);
+            return true;
+            
+        } catch ( Throwable t){
+            lastError = t;
+            return false;
+        }
+    }
+    
+    public boolean closeSocket() {
+        try {
+            socket.close();
+            ca.weblite.codename1.net.Socket.deleteBuffer(bufferId);
+            return true;
+        } catch ( Throwable t){
+            lastError = t;
+            return false;
+        }
+    }
+
+    public boolean writeBuf( byte[] buf) {
+        try {
+            socket.getOutputStream().write(buf);
+            return true;
+        } catch ( Throwable t){
+            lastError = t;
+            return false;
+        }
+    }
+
+
+    public boolean resetInputStream() {
+        try {
+            socket.getInputStream().reset();
+            return true;
+        } catch ( Throwable t){
+            lastError = t;
+            return false;
+        }
+    }
+
+    
+
+    public boolean isSocketConnected() {
+        return socket.isConnected();
+    }
+
+    public boolean markInputStream( int readLimit) {
+        try {
+            socket.getInputStream().mark(readLimit);
+            return true;
+        } catch ( Throwable t){
+            lastError = t;
+            return false;
+        }
+    }
+
+    public boolean isSocketClosed() {
+        return socket.isClosed();
+        
+    }
+
+    public boolean writeBuffOffsetLength( byte[] buf, int offset, int len) {
+        try {
+            socket.getOutputStream().write(buf, offset, len);
+            return true;
+        } catch ( Throwable t){
+            lastError = t;
+            return false;
+        }
+    }
+
+    public boolean flushOutputStream() {
+        try {
+            socket.getOutputStream().flush();
+            return true;
+        } catch ( Throwable t){
+            lastError = t;
+            return false;
+        }
+    }
+
+    public boolean isSupported() {
+        return true;
+    }
+
+}

CN1SocketsDemo/build.xml

@@ -0,0 +1,41 @@
+#import <Foundation/Foundation.h>
+#import "xmlvm.h"
+#import "ca_weblite_codename1_net_Socket.h"
+
+@interface ca_weblite_codename1_net_impl_NativeSocketImpl : NSObject {
+    NSInputStream* inputStream;
+    NSOutputStream* outputStream;
+    NSString* errorMessage;
+    int bufferId;
+    BOOL isFinished;
+}
+
+-(int)read;
+-(long long)skip:(long long)param;
+-(int)available;
+-(BOOL)markSupported;
+-(BOOL)setReceiveBufferSize:(int)param;
+-(BOOL)write:(int)param;
+-(void)setBufferId:(int)param;
+-(int)getBufferId;
+-(BOOL)setSendBufferSize:(int)param;
+-(BOOL)setKeepAlive:(BOOL)param;
+-(BOOL)isInputShutdown;
+-(BOOL)isOutputShutdown;
+-(NSString*)getErrorMessage;
+-(BOOL)closeOutputStream;
+-(int)readBuf:(int)len;
+-(BOOL)closeInputStream;
+-(int)getErrorCode;
+-(BOOL)createSocket:(NSString*)param param1:(int)param1;
+-(BOOL)closeSocket;
+-(BOOL)writeBuf:(NSData*)param;
+-(BOOL)flushOutputStream;
+-(BOOL)markInputStream:(int)param;
+-(BOOL)connectSocket:(int)param;
+-(BOOL)isSocketConnected;
+-(BOOL)isSocketClosed;
+-(BOOL)writeBuffOffsetLength:(NSData*)param param1:(int)param1 param2:(int)param2;
+-(BOOL)resetInputStream;
+-(BOOL)isSupported;
+@end