Instax SP-1 Android Source

InstaxProtocol.java

package com.Instax.sdk;

import java.io.*;
import java.util.*;
import android.graphics.Bitmap;
import android.graphics.Bitmap.CompressFormat;
import android.graphics.Color;
import android.util.Log;

import com.Instax.sdk.InstaxStatus.ErrCode;
import com.Instax.sdk.InstaxStatus.InstaxState;

class InstaxProtocol {
	private NetworkCommunicationParam Param = new NetworkCommunicationParam();
	private InstaxStatus State = new InstaxStatus();
	private NetworkCommunicationSndImageThread CommSndImageThread = null;
	private NetworkCommunicationPrintThread CommPrintThread = null;
	private int UID = (int)(System.currentTimeMillis());
	private final int EMERGENCY_ERR_LEVEL = 2;
	
	/**
	 * setNetworkParam
	 * @param ipAddress
	 * @param port
	 */
	void setNetworkParam(String ipAddress, int port) {
		InstaxLog.putLogToSD("IP:"+ipAddress);
		InstaxLog.putLogToSD("Port:"+String.valueOf(port));
		Param.setNetworkParam(ipAddress, port);
	}
	
	/**
	 * 
	 * @param pass
	 */
	void setSecurityPassword(int pass) {
		InstaxLog.putLogToSD("Pass:"+String.valueOf(pass));
		Param.setPassword(pass);
	}
	/**
	 * InstaxLock
	 * @param flg
	 * @return
	 */
	InstaxStatus InstaxLock(byte flg) {
		NetworkCommunication Sock = new NetworkCommunication();
		NetworkFrameData Frame = new NetworkFrameData();
		int DataSize = 4;
		byte[] Data = new byte[DataSize];
		short Sid = 0xB3;
		ErrCode err = ErrCode.RET_OK;
		
		// ‘—ŽóM
		Data[0] = flg;
		Data[1] = 0x00;
		Data[2] = 0x00;
		Data[3] = 0x00;
		Frame.CreateSndData( UID, Sid, Data, DataSize, Param.Password );
		err = Sock.SndRcvData( Param, Frame );
		if( err != ErrCode.RET_OK ) {
			State.setInstaxStatus(InstaxState.ST_BUSY, err);
			return State;
		}
		// ŽóMƒf[ƒ^ƒ`ƒFƒbƒN
		State = Frame.checkResponseFrame(0);
		
		return State;
	}
	/**
	 * getShadingData(0x40)
	 * @param shadingData
	 * @param size 
	 * @return
	 */
	InstaxStatus getShadingData(byte[] shadingData, int size) {
		NetworkCommunication Sock = new NetworkCommunication();
		NetworkFrameData Frame = new NetworkFrameData();
		int DataSize = 4;
		byte[] Data = new byte[DataSize];
		short Sid = 0x40;
		ErrCode err = ErrCode.RET_OK;
		
		for(int i=0; i<3; i++) {
			Data[0] = 0x00;
			Data[1] = 0x00;
			Data[2] = 0x00;
			Data[3] = (byte)i;
			// ‘—ŽóM
			Frame.CreateSndData( UID, Sid, Data, DataSize, Param.Password );
			err = Sock.SndRcvData( Param, Frame );
			if( err != ErrCode.RET_OK ) {
				State.setInstaxStatus(InstaxState.ST_BUSY, err);
				return State;
			}
			// ŽóMƒf[ƒ^ƒ`ƒFƒbƒN
			State = Frame.checkResponseFrame( size );
			//if( State.ErrCode != ErrCode.RET_OK ) {
			if( judgeErrLevel(State)  >= EMERGENCY_ERR_LEVEL ) {
				return State;
			}
			byte[] tmpData = new byte[size];
			if( Frame.getResponseArrayData(0, tmpData, size) != 0 ) {
				err = ErrCode.E_RCV_FRAME;
				State.setInstaxStatus(InstaxState.ST_BUSY,err);
				break;
			}
			System.arraycopy(tmpData, 0, shadingData, i*size, size);
		}
		return State;
	}
	
	/**
	 * 
	 * @param imageData
	 * @param printWidth
	 * @param printHeight
	 * @param sndFinish
	 * @param shadingData 
	 * @param option
	 * @return
	 */
	//InstaxStatus sndImage(Bitmap imageData, int printWidth, int printHeight, InstaxCallBack sndFinish, byte[] shadingData) {
	InstaxStatus sndImage(Bitmap imageData, int printWidth, int printHeight, InstaxCallBack sndFinish, byte[] shadingData, String option) {
		NetworkCommunication sock = new NetworkCommunication();
		NetworkFrameData Frame = new NetworkFrameData();
		ErrCode err = ErrCode.RET_OK;
		int DataSize;
		byte[] Data;
		short Sid;
		
		if( CommSndImageThread != null ) {
			if( CommSndImageThread.isAlive() ) {
				// ‘OƒXƒŒƒbƒh‚ª‚Ü‚¾¶‚«‚Ä‚¢‚é
				State.setInstaxStatus(InstaxState.ST_BUSY, ErrCode.E_CONNECT);
				sndFinish.FinishCallBack(State);
				return State;
			}
		}
		
		// 0x50
		DataSize = 0;
		Data = new byte[DataSize];
		Sid = 0x50;
		//Data[0] = 0x00;	// RAM page
		// ‘—ŽóM
		Frame.CreateSndData( UID, Sid, Data, DataSize, Param.Password );
		err = sock.SndRcvData( Param, Frame );
		if( err != ErrCode.RET_OK ) {
			//InstaxLock((byte)0x00);
			State.setInstaxStatus(InstaxState.ST_BUSY, err);
			sndFinish.FinishCallBack(State);
			return State;
		}
		State = Frame.checkResponseFrame( 0 );
		if( State.ErrCode != ErrCode.RET_OK ) {
			//InstaxLock((byte)0x00);
			sndFinish.FinishCallBack(State);
			return State;
		}
		
		// ‰æ‘œƒf[ƒ^‰ÁH
		int sndMaxSize = Param.MaxFrameSize;
		int width = imageData.getWidth();			// ‰æ‘œ•
		int height = imageData.getHeight();			// ‰æ‘œ‚‚³
		int imageSize = width * height;				// ‰æ‘œƒTƒCƒY
		int printSize = printWidth * printHeight;	// ˆóüƒTƒCƒY
		int[] printRGB = new int[printSize];
		int[] imageRGB = new int[imageSize];
		int x,y;
		
		// ‰Šú‰»
		Arrays.fill(printRGB, 0x00FFFFFF);		// ”’‰æ–Ê‚ð—pˆÓ
		// ƒsƒNƒZƒ‹î•ñGET
		imageData.getPixels( imageRGB, 0, width, 0, 0, width, height );
		// ƒRƒs[ŠJŽnÀ•WŽZo
		x = (printWidth - width)/2;
		y = (printHeight - height)/2;
		// ƒRƒs[
		for(int i=0; i<height; i++) {
			// ”’‰æ–ʂɉ摜‚ðƒRƒs[
			System.arraycopy(imageRGB, i*width, printRGB, (i+y)*printWidth+x, width);
		}
		imageRGB = null;
		// ‚±‚±‚Ü‚Å‚Å”’–„‚߉摜‚ªo—ˆ‚Ä‚¢‚é

		// RBG•Ê‚É•ª‰ð+ƒVƒF[ƒfƒBƒ“ƒO•â³
		// R(0,0),R(0,1),...,R(0,479), G(0,0),G(0,1),...,G(0,479), B(0,0),B(0,1),...,B(0,479),
		// R(1,0),R(1,1),...
		if( shadingData.length < 3*printWidth ) {
			// ƒVƒF[ƒfƒBƒ“ƒOƒf[ƒ^Žæ“¾‚µ‚Ä‚¢‚È‚©‚Á‚½‚ç‚Æ‚è‚ ‚¦‚¸rank‚O‚ŕ␳‚©‚¯‚¿‚Ⴄ
			shadingData = new byte[3*printWidth];
			Arrays.fill(shadingData, (byte)0x00);
		}
		Data = new byte[printSize*3];
		ShadingTableAccess shadingTableAccess = new ShadingTableAccess();
		int beforeR, beforeG, beforeB;
		for(int i=0; i<printHeight; i++) {
			for(int j=0; j<printWidth; j++ ) {
				// •â³Œã‚Ì’l‚ð“ü‚ê‚é
				int idx = i*printWidth+j;
				beforeR = Color.red(printRGB[idx]);
				beforeG = Color.green(printRGB[idx]);
				beforeB = Color.blue(printRGB[idx]);
				
				// (i*printWidth*3)+j+0*printWidth ¨ (i*3+0)*printWidth+j
				Data[(i*3+0)*printWidth+j] = shadingTableAccess.getTableDataR( ((int)shadingData[j+0*printWidth] & 0xFF),beforeR );
				Data[(i*3+1)*printWidth+j] = shadingTableAccess.getTableDataG( ((int)shadingData[j+1*printWidth] & 0xFF),beforeG );
				Data[(i*3+2)*printWidth+j] = shadingTableAccess.getTableDataB( ((int)shadingData[j+2*printWidth] & 0xFF),beforeB );
			}
		}
		shadingTableAccess = null;
		
		// JPG:ˆ³k
		if(Param.IMAGE_Format == 2)
		{
			final int encodedSizeMax = 150*1024;		// 150k
			// byteŒ^”z—ñ‚ðintŒ^”z—ñ‚É–ß‚·
			int alpha = 0xFF000000;		// ƒ¿’l‚ðŽg‚í‚È‚¢‚Æ‚«‚Í0xFF‚ð“ü‚ê‚é
			for(int i=0; i<printHeight; i++) {
				for(int j=0; j<printWidth; j++ ) {
					beforeR = ((((int)Data[(i*3+0)*printWidth+j]) << 16) & 0xFF0000);
					beforeG = ((((int)Data[(i*3+1)*printWidth+j]) <<  8) & 0x00FF00);
					beforeB = ((((int)Data[(i*3+2)*printWidth+j]) <<  0) & 0x0000FF);
					printRGB[i*printWidth+j] = (alpha | beforeR | beforeG | beforeB);
				}
			}
			
			// Android‚ÌBitmapƒNƒ‰ƒX‚ð—˜—p‚µ‚ÄJPGˆ³k
			//if(Param.Port == 8080)
			{
				Bitmap bmp = Bitmap.createBitmap(printRGB, printWidth, printHeight, Bitmap.Config.ARGB_8888);
				ByteArrayOutputStream baos = new ByteArrayOutputStream();
				int encodedSize;
				int jpgQuality = 100;	// ‰Šú’l100
				Log.d("jpeg","encodedSizeMax:"+String.valueOf(encodedSizeMax));
				while(true) {
					bmp.compress(CompressFormat.JPEG, jpgQuality, baos);
					encodedSize = baos.size();
					
					Log.d("jpeg","Quality:"+String.valueOf(jpgQuality));
					Log.d("jpeg","encodedSize:"+String.valueOf(encodedSize));
					
					if(encodedSize <= encodedSizeMax) {
						// ˆ³kŒãƒTƒCƒY‚ªÅ‘å—e—Ê‚æ‚菬‚³‚©‚Á‚½‚甲‚¯‚é
						String log = String.format("JPG Quality:%d", jpgQuality);
						InstaxLog.putLogToSD(log);
						break;
					}
					baos.reset();
					jpgQuality -= 10;		// •iŽ¿‚ð—Ž‚Æ‚·
					if(jpgQuality < 0) {
						// Å’á•iŽ¿‚Å‚àÅ‘å—e—ʈȉº‚É‚¨‚³‚Ü‚ç‚È‚¢‚̂ŃGƒ‰[
						encodedSize = 0;
						baos.reset();
						Log.e("jpeg","encode fail");
						break;
					}
				}
				if(encodedSize > 0) {
					Data = new byte[encodedSize];
					Data = baos.toByteArray();
				}
				else {
					printRGB = null;
					State.setInstaxStatus(InstaxState.ST_BUSY, ErrCode.E_MEMORY);
					sndFinish.FinishCallBack(State);
					return State;
				}
			} 
			// MT»‚ÌJPGˆ³k
			//else
//			{
//				// ˆ³k—¦‚̕ύX•û–@•s–¾
//				for(int i=0; i<printWidth*printHeight; i++) {
//					Data[i*3+0] = (byte)((printRGB[i] >> 16) & 0xFF);
//					Data[i*3+1] = (byte)((printRGB[i] >>  8) & 0xFF);
//					Data[i*3+2] = (byte)((printRGB[i] >>  0) & 0xFF);
//				}
//				//Arrays.fill(Data, (byte)0xFF);
//				JpegEncode jpg = new JpegEncode(Data);
//				JpegEncodeInfo info = new JpegEncodeInfo();
//				info.uswNumSamplesPerLine = printWidth;
//				info.uswNumLines = printHeight;
//				jpg.jpeg_encode(info);
//				Data = new byte[(int)info.uinInputFileSize];
//				//Log.d("jpeg", "size:"+String.valueOf(info.uinInputFileSize));
//				System.arraycopy(info.pbOutputData, 0, Data, 0, (int)info.uinInputFileSize);
//			}
		}
		printRGB = null;
	/*
	 * ƒXƒŒƒbƒh“à‚Ɉړ®
		// 0x51
		int imgSize = Data.length;
		DataSize = 12;
		Data = new byte[DataSize];
		Sid = 0x51;
		Data[0] = (byte)Param.JpgFlg;	// ‰æ‘œƒtƒH[ƒ}ƒbƒg
		Data[1] = 0x00;		// pic opt
		Data[2] = (byte)(((int)imgSize >> 24) & 0xFF);		// size
		Data[3] = (byte)(((int)imgSize >> 16) & 0xFF);
		Data[4] = (byte)(((int)imgSize >> 8) & 0xFF);;
		Data[5] = (byte)(((int)imgSize >> 0) & 0xFF);;		
		Data[6] = 0x00;		// jpg param
		Data[7] = 0x00;
		Data[8] = 0x00;
		Data[9] = 0x00;
		Data[10] = 0x00;	// reserve
		Data[11] = 0x00;	// reserve
		// ‘—ŽóM
		Frame.CreateSndData( UID, Sid, Data, DataSize );
		err = sock.SndRcvData( Param, Frame );
		if( err != ErrCode.RET_OK ) {
			ModeReset();
			State.setInstaxStatus(InstaxState.ST_BUSY, err);
			return State;
		}
		State = Frame.checkResponseFrame( 0 );
		if( State.ErrCode != ErrCode.RET_OK ) {
			ModeReset();
			return State;
		}
		*/
		String log = String.format("IMG Size:%d", Data.length);
		InstaxLog.putLogToSD(log);
		
		Param.IMAGE_Option = AnalyzeOption(option);
		// 0x51,0x52,0x53
		Sid = 0x52;
		CommSndImageThread = new NetworkCommunicationSndImageThread(Param, UID, Sid, Data, sndMaxSize, sndFinish);
		CommSndImageThread.start();
		
		return State;
	}
	
	/*
	 * 
	 */
	private int AnalyzeOption(String option) {
		int ret = 0;
		if( option == null ) {
			return ret;
		}
		InstaxLog.putLogToSD("Tag:"+option);
		// ‚·‚ׂđ啶Žš‚É•ÏŠ·
		option = option.toUpperCase();
		
		// FujifilmOptionŒŸõ
		if( option.indexOf("FUJIFILMOPTION") == -1 ) {
			InstaxLog.putLogToSD("Tag:"+"0");
			return ret;
		}
		//@CLEARALLŒŸõ
		if( option.indexOf("CLEARALL") != -1 ) {
			ret |= 0x10;
		}
		// FORCEPRINTŒŸõ
		if( option.indexOf("FORCEPRT") != -1 ) {
			ret |= 0x30;
		}
		// LUTŒŸõ
		int index;
		if( (index=option.indexOf("LUT")) != -1 ) {
			// "LUT"‚ÌŽŸ‚Ì•¶Žš‚𒊏o
			String tmp = option.substring(index+3, index+4);
			int num = 0;
			try {
				// ”’l‚É•ÏŠ·
				num = Integer.parseInt(tmp);
			} catch(NumberFormatException e) {
				num = 0;
			}
			ret |= (0x10+num);
		}
		String log = String.format("Tag:%02X", ret);
		InstaxLog.putLogToSD(log);
		return ret;
	}

	 /**
	  * getSndImageProgress
	  * @return
	  */
	int getSndImageProgress() {
		if( CommSndImageThread == null || !CommSndImageThread.isAlive() ) {
				return 0;
		}
		return CommSndImageThread.getProgress();
	}

	/**
	 * sndImageCancel
	 * @param cancelFinish
	 * @return
	 */
	InstaxStatus sndImageCancel(InstaxCallBack cancelFinish) {
		if( CommSndImageThread == null || !CommSndImageThread.isAlive() ) {
			State.setInstaxStatus(InstaxState.ST_IDLE,ErrCode.RET_OK);
			cancelFinish.FinishCallBack(State);
			return State;
		}
		CommSndImageThread.SndImageCancel(cancelFinish);
		
		State.setInstaxStatus(InstaxState.ST_IDLE,ErrCode.RET_OK);
		return State;
	}

	/**
	 * startPrint(0xB0)
	 * @param printFinish
	 * @return
	 */
	InstaxStatus startPrint(InstaxCallBack printFinish) {
		NetworkCommunication Sock = new NetworkCommunication();
		NetworkFrameData Frame = new NetworkFrameData();
		int DataSize = 0;
		byte[] Data = new byte[DataSize];
		short Sid = 0xB0;
		ErrCode err = ErrCode.RET_OK;
		
		if( CommPrintThread != null ) {
			if( CommPrintThread.isAlive() ) {
				// ‘OƒXƒŒƒbƒh‚ª‚Ü‚¾¶‚«‚Ä‚¢‚é
				State.setInstaxStatus(InstaxState.ST_BUSY,err);
				printFinish.FinishCallBack(State);
				return State;
			}
		}
		
		// ‘—M
		Frame.CreateSndData( UID, Sid, Data, DataSize, Param.Password );
		err = Sock.SndRcvData( Param, Frame );
		if( err != ErrCode.RET_OK) {
			State.setInstaxStatus(InstaxState.ST_BUSY,err);
			printFinish.FinishCallBack(State);
			return State;
		}
		
		// ŽóMƒf[ƒ^ƒ`ƒFƒbƒN
		State = Frame.checkResponseFrame(4);
		if( State.ErrCode != ErrCode.RET_OK ) {
			printFinish.FinishCallBack(State);
			return State;
		}
		int printTime = Frame.getResponselongData(0)/10;	// 100ms’PˆÊ‚Å‚­‚é‚Ì‚Å1/10‚µ‚Ä•b‚É‚·‚é
		
		CommPrintThread = new NetworkCommunicationPrintThread(Param, UID, (short)0xC3, printTime, printFinish);
		CommPrintThread.start();
		
		return State;
	}

	/**
	 * getPrintProgress
	 * @return
	 */
	int getPrintProgress() {
		if( CommPrintThread == null || !CommPrintThread.isAlive() ) {
			return 0;
		}
		return CommPrintThread.getProgress();
	}

	/**
	 * printCancel
	 * @param cancelFinish
	 * @return
	 */
	InstaxStatus printCancel(InstaxCallBack cancelFinish) {
		if( CommPrintThread == null || !CommPrintThread.isAlive() ) {
			State.setInstaxStatus(InstaxState.ST_IDLE,ErrCode.RET_OK);
			cancelFinish.FinishCallBack(State);
			return State;
		}
		CommPrintThread.PrintCancel(cancelFinish);
		
		State.setInstaxStatus(InstaxState.ST_IDLE,ErrCode.RET_OK);
		return State;
	}
	
	/**
	 * getVersion(0xC0)
	 * @param info
	 * @return
	 */
	InstaxStatus getVersion(InstaxInfo info) {
		NetworkCommunication Sock = new NetworkCommunication();
		NetworkFrameData Frame = new NetworkFrameData();
		ErrCode err = ErrCode.RET_OK;
		int DataSize = 0;
		byte[] Data = new byte[DataSize];
		short Sid = 0xC0;
		
		// ƒf[ƒ^ì¬
		Frame.CreateSndData( UID, Sid, Data, DataSize, Param.Password );
		// ‘—ŽóM
		err = Sock.SndRcvData( Param, Frame );
		if( err != ErrCode.RET_OK) {
			State.setInstaxStatus(InstaxState.ST_BUSY,err);
			return State;
		}
		// ŽóMƒf[ƒ^Žæ“¾
		State = Frame.checkResponseFrame(8);
		//if( State.ErrCode != ErrCode.RET_OK ) {
		if( judgeErrLevel(State)  >= EMERGENCY_ERR_LEVEL ) {
			return State;
		}
		info.BootVer = Frame.getResponseShortData( 0 );
		info.FwVer   = Frame.getResponseShortData( 2 );
		info.FpgaVer = Frame.getResponseShortData( 4 );
		
		return State;
	}
	
	/**
	 * getInstaxParameter(0xC1)
	 * @param info
	 * @return
	 */
	InstaxStatus getInstaxParameter(InstaxInfo info) {
		NetworkCommunication Sock = new NetworkCommunication();
		NetworkFrameData Frame = new NetworkFrameData();
		int DataSize = 0;
		byte[] Data = new byte[DataSize];
		short Sid = 0xC1;
		
		// ƒf[ƒ^ì¬
		Frame.CreateSndData( UID, Sid, Data, DataSize, Param.Password );
		// ‘—ŽóM
		ErrCode err = Sock.SndRcvData( Param, Frame );
		if( err != ErrCode.RET_OK) {
			State.setInstaxStatus(InstaxState.ST_BUSY,err);
			return State;
		}
		// ŽóMƒf[ƒ^Žæ“¾
		State = Frame.checkResponseFrame(12);
		//if( State.ErrCode != ErrCode.RET_OK ) {
		if( judgeErrLevel(State) >= EMERGENCY_ERR_LEVEL ) {
			return State;
		}
		int temp;
		info.PrintCount = Frame.getResponselongData(0);
		
		//temp = Frame.getResponseSignedShortData( 4 );
		//info.InstaxTemp = (float)temp/10;
		
		switch(Frame.getInfoBattery()) {
		case 0x00:
		case 0x01:
		case 0x02:
		case 0x03:
			temp = Frame.getInfoBattery();
			break;
		case 0x04:
		default:
			temp = -1;		// DC
			break;
		}
		info.Battery = temp;
		
		info.FilmNum = Frame.getInfoFilm();
		if( info.FilmNum > 10 ) {
			info.FilmNum = 0;
		}
		info.FilmMax = 10;
		info.ImageHeight = 640;
		info.ImageWidth = 480;
		
		return State;	
	}
	
	/**
	 * getInstaxName(0xC2)
	 * @param info
	 * @return
	 */
	InstaxStatus getInstaxName(InstaxInfo info) {
		NetworkCommunication Sock = new NetworkCommunication();
		NetworkFrameData Frame = new NetworkFrameData();
		int DataSize = 0;
		byte[] Data = new byte[DataSize];
		short Sid = 0xC2;
		
		// ƒf[ƒ^ì¬
		Frame.CreateSndData( UID, Sid, Data, DataSize, Param.Password );
		// ‘—ŽóM
		ErrCode err = Sock.SndRcvData( Param, Frame );
		if( err != ErrCode.RET_OK) {
			State.setInstaxStatus(InstaxState.ST_BUSY,err);
			return State;
		}
		// ŽóMƒf[ƒ^Žæ“¾
		State = Frame.checkResponseFrame(0);
		//if( State.ErrCode != ErrCode.RET_OK ) {
		if( judgeErrLevel(State)  >= EMERGENCY_ERR_LEVEL ) {
			return State;
		}
		info.TargetName = Frame.getResponseStringData(0);
		
		return State;	
	}

	/**
	 * getInstaxStatus
	 * @return
	 */
	InstaxStatus getInstaxStatus() {
		InstaxInfo info = new InstaxInfo();
		State =  getInstaxName(info);
		return State;
	}
	
	/**
	 * setCommunicationParam
	 * @param sndTimeOut
	 * @param rcvTimeOut
	 * @param retryCnt
	 */
	void setCommunicationParam(int sndTimeOut, int rcvTimeOut, int retryCnt) {
		InstaxLog.putLogToSD("SndTimeOut:"+String.valueOf(sndTimeOut));
		InstaxLog.putLogToSD("RcvTimeOut:"+String.valueOf(rcvTimeOut));
		InstaxLog.putLogToSD("RetryCount:"+String.valueOf(retryCnt));
		Param.setCommunicationParam(sndTimeOut, rcvTimeOut, retryCnt);
	}

	/**
	 * 
	 * @param sndMaxSize
	 * @param delayTime
	 */
	void setDebugParam(int sndMaxSize, int delayTime, int jpgFlg, int jpgOpt) {
		Param.setDebugParam(sndMaxSize, delayTime, jpgFlg, jpgOpt);
	}
	
	/**
	 * 
	 * @param param
	 */
	void getDebugParam(InstaxPrintSetting param) {
		param.MaxFrameSize = this.Param.MaxFrameSize;
		param.DelayTime = this.Param.DelayTime;
		param.IMAGE_Format = this.Param.IMAGE_Format;
		param.IMAGE_Option = this.Param.IMAGE_Option;
	}
	/**
	 * setLedElectricAndWhiteMark(0x30)
	 * @param param
	 * @return
	 */
/*
	InstaxStatus setLedElectricAndWhiteMark(InstaxPrintSetting param) {
		NetworkCommunication Sock = new NetworkCommunication();
		NetworkFrameData Frame = new NetworkFrameData();
		int DataSize = 8;
		byte[] Data = new byte[DataSize];
		short Sid = 0x30;
		
		// ƒf[ƒ^ì¬
		Data[0] = (byte)((param.LedRed >> 8) & 0xFF);
		Data[1] = (byte)((param.LedRed >> 0) & 0xFF);
		Data[2] = (byte)((param.LedGreen >> 8) & 0xFF);
		Data[3] = (byte)((param.LedGreen >> 0) & 0xFF);
		Data[4] = (byte)((param.LedBlue >> 8) & 0xFF);
		Data[5] = (byte)((param.LedBlue >> 0) & 0xFF);
		Data[6] = 0x00;
		Data[7] = 0x00;
//		Data[6] = (byte)((param.BeforeWhite >> 8) & 0xFF);
//		Data[7] = (byte)((param.BeforeWhite >> 0) & 0xFF);
//		Data[8] = (byte)((param.AfterWhite >> 8) & 0xFF);
//		Data[9] = (byte)((param.AfterWhite >> 0) & 0xFF);
		
		Frame.CreateSndData( UID, Sid, Data, DataSize );
		// ‘—ŽóM
		ErrCode err = Sock.SndRcvData( Param, Frame );
		if( err != ErrCode.RET_OK) {
			State.setInstaxStatus(InstaxState.ST_BUSY,err);
			return State;
		}
		// ŽóMƒf[ƒ^Žæ“¾
		State = Frame.checkResponseFrame(0);
		
		return State;	
	}
*/
	/**
	 * setLcs(0x31)
	 * @param param
	 * @return
	 */
/*
	InstaxStatus setLcs(InstaxPrintSetting param) {
		NetworkCommunication Sock = new NetworkCommunication();
		NetworkFrameData Frame = new NetworkFrameData();
		int DataSize = 22;
		byte[] Data = new byte[DataSize];
		short Sid = 0x31;
		
		// ƒf[ƒ^ì¬
		Data[0] = (byte)((param.LpCycle >> 8) & 0xFF);
		Data[1] = (byte)((param.LpCycle >> 0) & 0xFF);
		Data[2] = (byte)((param.ExposureRed >> 8) & 0xFF);
		Data[3] = (byte)((param.ExposureRed >> 0) & 0xFF);
		Data[4] = (byte)((param.ExposureGreen >> 8) & 0xFF);
		Data[5] = (byte)((param.ExposureGreen >> 0) & 0xFF);
		Data[6] = (byte)((param.ExposureBlue >> 8) & 0xFF);
		Data[7] = (byte)((param.ExposureBlue >> 0) & 0xFF);
		Data[8] = (byte)((param.OpenRed >> 8) & 0xFF);
		Data[9] = (byte)((param.OpenRed >> 0) & 0xFF);
		Data[10] = (byte)((param.OpenGreen >> 8) & 0xFF);
		Data[11] = (byte)((param.OpenGreen >> 0) & 0xFF);
		Data[12] = (byte)((param.OpenBlue >> 8) & 0xFF);
		Data[13] = (byte)((param.OpenBlue >> 0) & 0xFF);
		Data[14] = (byte)((param.CloseRed >> 8) & 0xFF);
		Data[15] = (byte)((param.CloseRed >> 0) & 0xFF);
		Data[16] = (byte)((param.CloseGreen >> 8) & 0xFF);
		Data[17] = (byte)((param.CloseGreen >> 0) & 0xFF);
		Data[18] = (byte)((param.CloseDummy >> 8) & 0xFF);
		Data[19] = (byte)((param.CloseDummy >> 0) & 0xFF);
		Data[20] = (byte)((param.ExposureDummy >> 8) & 0xFF);
		Data[21] = (byte)((param.ExposureDummy >> 0) & 0xFF);
		
		Frame.CreateSndData( UID, Sid, Data, DataSize );
		// ‘—ŽóM
		ErrCode err = Sock.SndRcvData( Param, Frame );
		if( err != ErrCode.RET_OK) {
			State.setInstaxStatus(InstaxState.ST_BUSY,err);
			return State;
		}
		// ŽóMƒf[ƒ^Žæ“¾
		State = Frame.checkResponseFrame(0);
		
		return State;	
	}
*/
	/**
	 * setMovementAndMotorSpeedAndEnergisationMode(0xE1)
	 * @param param
	 * @return
	 */
/*
	InstaxStatus setMovementAndMotorSpeedAndEnergisationMode(InstaxPrintSetting param) {
		NetworkCommunication Sock = new NetworkCommunication();
		NetworkFrameData Frame = new NetworkFrameData();
		int DataSize = 28;
		byte[] Data = new byte[DataSize];
		short Sid = 0xE1;
		
		// ƒf[ƒ^ì¬
		Data[0] = (byte)((param.BeforeWhite >> 8) & 0xFF);
		Data[1] = (byte)((param.BeforeWhite >> 0) & 0xFF);
		Data[2] = (byte)((param.AfterWhite >> 8) & 0xFF);
		Data[3] = (byte)((param.AfterWhite >> 0) & 0xFF);
		Data[4] = (byte)((param.StepPerLine >> 8) & 0xFF);
		Data[5] = (byte)((param.StepPerLine >> 0) & 0xFF);
		Data[6] = (byte)((param.OrgToPiStep >> 8) & 0xFF);
		Data[7] = (byte)((param.OrgToPiStep >> 0) & 0xFF);
		Data[8] = (byte)((param.SpeedUpStep >> 8) & 0xFF);
		Data[9] = (byte)((param.SpeedUpStep >> 0) & 0xFF);
		Data[10] = (byte)((param.SpeedDnStep >> 8) & 0xFF);
		Data[11] = (byte)((param.SpeedDnStep >> 0) & 0xFF);
		Data[12] = (byte)((param.MainStep >> 8) & 0xFF);
		Data[13] = (byte)((param.MainStep >> 0) & 0xFF);
		Data[14] = (byte)((param.AfterPrintStep >> 8) & 0xFF);
		Data[15] = (byte)((param.AfterPrintStep >> 0) & 0xFF);
		Data[16] = (byte)((param.ReturnStep >> 8) & 0xFF);
		Data[17] = (byte)((param.ReturnStep >> 0) & 0xFF);
		Data[18] = (byte)((param.LowSpeed >> 8) & 0xFF);
		Data[19] = (byte)((param.LowSpeed >> 0) & 0xFF);
		Data[20] = (byte)((param.PrintSpeed >> 8) & 0xFF);
		Data[21] = (byte)((param.PrintSpeed >> 0) & 0xFF);
		Data[22] = (byte)((param.ReturnSpeed >> 8) & 0xFF);
		Data[23] = (byte)((param.ReturnSpeed >> 0) & 0xFF);
		Data[24] = (byte)((param.Excitation >> 0) & 0xFF);
		Data[25] = (byte)((param.LedOpen >> 0) & 0xFF);
		Data[26] = 0x00;
		Data[27] = 0x00;
		
		Frame.CreateSndData( UID, Sid, Data, DataSize );
		// ‘—ŽóM
		ErrCode err = Sock.SndRcvData( Param, Frame );
		if( err != ErrCode.RET_OK) {
			State.setInstaxStatus(InstaxState.ST_BUSY,err);
			return State;
		}
		// ŽóMƒf[ƒ^Žæ“¾
		State = Frame.checkResponseFrame(0);
		
		return State;	
	}
*/
	/**
	 * getLedElectricAndWhiteMark(0x40)
	 * @param param
	 * @return
	 */
/*
	InstaxStatus getLedElectricAndWhiteMark(InstaxPrintSetting param) {
		NetworkCommunication Sock = new NetworkCommunication();
		NetworkFrameData Frame = new NetworkFrameData();
		ErrCode err = ErrCode.RET_OK;
		int DataSize = 0;
		byte[] Data = new byte[DataSize];
		short Sid = 0x40;
		
		// ƒf[ƒ^ì¬
		Frame.CreateSndData( UID, Sid, Data, DataSize );
		// ‘—ŽóM
		err = Sock.SndRcvData( Param, Frame );
		if( err != ErrCode.RET_OK) {
			State.setInstaxStatus(InstaxState.ST_BUSY,err);
			return State;
		}
		// ŽóMƒf[ƒ^Žæ“¾
		State = Frame.checkResponseFrame(8);
		//if( State.ErrCode != ErrCode.RET_OK ) {
		if( judgeErrLevel(State)  >= EMERGENCY_ERR_LEVEL ) {
			return State;
		}
		param.LedRed      = Frame.getResponseShortData( 0 );
		param.LedGreen    = Frame.getResponseShortData( 2 );
		param.LedBlue     = Frame.getResponseShortData( 4 );
//		param.BeforeWhite = Frame.getResponseShortData( 6 );
//		param.AfterWhite  = Frame.getResponseShortData( 8 );
		
		return State;
	}
*/
	/**
	 * getLcs(0x41)
	 * @param param
	 * @return
	 */
/*
	InstaxStatus getLcs(InstaxPrintSetting param) {
		NetworkCommunication Sock = new NetworkCommunication();
		NetworkFrameData Frame = new NetworkFrameData();
		ErrCode err = ErrCode.RET_OK;
		int DataSize = 0;
		byte[] Data = new byte[DataSize];
		short Sid = 0x41;
		
		// ƒf[ƒ^ì¬
		Frame.CreateSndData( UID, Sid, Data, DataSize );
		// ‘—ŽóM
		err = Sock.SndRcvData( Param, Frame );
		if( err != ErrCode.RET_OK) {
			State.setInstaxStatus(InstaxState.ST_BUSY,err);
			return State;
		}
		// ŽóMƒf[ƒ^Žæ“¾
		State = Frame.checkResponseFrame(22);
		//if( State.ErrCode != ErrCode.RET_OK ) {
		if( judgeErrLevel(State)  >= EMERGENCY_ERR_LEVEL ) {
			return State;
		}
		param.LpCycle       = Frame.getResponseShortData( 0 );
		param.ExposureRed   = Frame.getResponseShortData( 2 );
		param.ExposureGreen = Frame.getResponseShortData( 4 );
		param.ExposureBlue  = Frame.getResponseShortData( 6 );
		param.OpenRed       = Frame.getResponseShortData( 8 );
		param.OpenGreen     = Frame.getResponseShortData( 10 );
		param.OpenBlue      = Frame.getResponseShortData( 12 );
		param.CloseRed      = Frame.getResponseShortData( 14 );
		param.CloseGreen    = Frame.getResponseShortData( 16 );
		param.CloseDummy    = Frame.getResponseShortData( 18 );
		param.ExposureDummy = Frame.getResponseShortData( 20 );
		
		return State;
	}
*/
	/**
	 * getMovementAndMotorSpeedAndEnergisationMode(0xE2)
	 * @param param
	 * @return
	 */
/*
	InstaxStatus getMovementAndMotorSpeedAndEnergisationMode(InstaxPrintSetting param) {
		NetworkCommunication Sock = new NetworkCommunication();
		NetworkFrameData Frame = new NetworkFrameData();
		ErrCode err = ErrCode.RET_OK;
		int DataSize = 0;
		byte[] Data = new byte[DataSize];
		short Sid = 0xE2;
		
		// ƒf[ƒ^ì¬
		Frame.CreateSndData( UID, Sid, Data, DataSize );
		// ‘—ŽóM
		err = Sock.SndRcvData( Param, Frame );
		if( err != ErrCode.RET_OK) {
			State.setInstaxStatus(InstaxState.ST_BUSY,err);
			return State;
		}
		// ŽóMƒf[ƒ^Žæ“¾
		State = Frame.checkResponseFrame(28);
		//if( State.ErrCode != ErrCode.RET_OK ) {
		if( judgeErrLevel(State)  >= EMERGENCY_ERR_LEVEL ) {
			return State;
		}
		param.BeforeWhite    = Frame.getResponseShortData( 0 );
		param.AfterWhite     = Frame.getResponseShortData( 2 );
		param.StepPerLine    = Frame.getResponseShortData( 4 );
		param.OrgToPiStep    = Frame.getResponseShortData( 6 );
		param.SpeedUpStep    = Frame.getResponseShortData( 8 );
		param.SpeedDnStep    = Frame.getResponseShortData( 10 );
		param.MainStep       = Frame.getResponseShortData( 12 );
		param.AfterPrintStep = Frame.getResponseShortData( 14 );
		param.ReturnStep     = Frame.getResponseShortData( 16 );
		param.LowSpeed       = Frame.getResponseShortData( 18 );
		param.PrintSpeed     = Frame.getResponseShortData( 20 );
		param.ReturnSpeed    = Frame.getResponseShortData( 22 );
		param.Excitation     = Frame.getResponseByteData( 24 );
		param.LedOpen        = Frame.getResponseByteData( 25 );
		
		return State;
	}
*/
	/**
	 * GetFunctionVersion(0xC4)
	 * @param FuncMap
	 * @return
	 */
	//InstaxStatus GetFunctionVersion(int functionId, Integer version) {
	InstaxStatus GetFunctionVersion(Map<Integer, Integer> FuncMap) {
		NetworkCommunication Sock = new NetworkCommunication();
		NetworkFrameData Frame = new NetworkFrameData();
		ErrCode err = ErrCode.RET_OK;
		int DataSize = 4;
		byte[] Data = new byte[DataSize];
		short Sid = 0xC4;
		
		for(Integer key : FuncMap.keySet()) {
			// ƒf[ƒ^ì¬
			Data[0] = 0x00;
			Data[1] = 0x00;
			Data[2] = (byte)((key.intValue() >> 8) & 0xFF);
			Data[3] = (byte)((key.intValue() >> 0) & 0xFF);
			Frame.CreateSndData( UID, Sid, Data, DataSize, Param.Password );
			// ‘—ŽóM
			err = Sock.SndRcvData( Param, Frame );
			if( err != ErrCode.RET_OK) {
				State.setInstaxStatus(InstaxState.ST_BUSY,err);
				return State;
			}
			// ŽóMƒf[ƒ^Žæ“¾
			State = Frame.checkResponseFrame(4);
			//if( State.ErrCode != ErrCode.RET_OK ) {
			if( judgeErrLevel(State)  >= EMERGENCY_ERR_LEVEL ) {
				return State;
			}
			FuncMap.put(key, Integer.valueOf(Frame.getResponseShortData(2)));
		}
		return State;
	}

	/**
	 * InstaxPowerOff(0xB4)
	 * @return
	 */
	InstaxStatus InstaxPowerOff() {
		NetworkCommunication Sock = new NetworkCommunication();
		NetworkFrameData Frame = new NetworkFrameData();
		NetworkCommunicationParam PowerOffParam = new NetworkCommunicationParam();
		ErrCode err = ErrCode.RET_OK;
		int DataSize = 4;
		byte[] Data = new byte[DataSize];
		short Sid = 0xB4;
		
		// PowerOff‚̓ŒƒXƒ|ƒ“ƒX‚ð‘Ò‚½‚È‚¢‚Ì‚Å‘¼ƒRƒ}ƒ“ƒh‚Ƃ̓pƒ‰ƒ[ƒ^[‚ð•ÏX‚·‚é
		PowerOffParam.setNetworkParam(Param.IpAddress, Param.Port);
		PowerOffParam.setCommunicationParam(Param.SndTimeOut, 0, 0);
		PowerOffParam.setPassword(Param.Password);
	
		// ƒf[ƒ^ì¬
		Data[0] = 0x00;
		Data[1] = 0x00;
		Data[2] = 0x00;
		Data[3] = 0x00;
		Frame.CreateSndData( UID, Sid, Data, DataSize, PowerOffParam.Password );
		
		// ‘—M‚ªŠ®—¹‚µ‚½Žž“_‚Å”²‚¯‚邽‚ß‚É‚±‚Ì‘w‚ŃŠƒgƒ‰ƒCˆ—‚ðs‚¤
		for(int i=0; i<=Param.RetryCnt; i++) {
			// ‘—ŽóM
			err = Sock.SndRcvData( PowerOffParam, Frame );
			if( err == ErrCode.RET_OK || err == ErrCode.E_RCV_TIMEOUT ) {	//ƒ^ƒCƒ€ƒAƒEƒg‚̓Xƒ‹[
				State.setInstaxStatus(InstaxState.ST_IDLE, ErrCode.RET_OK);
				break;
			}
			else {
				State.setInstaxStatus(InstaxState.ST_BUSY,err);
			}
		}
		
		// ŽóMƒf[ƒ^Žæ“¾
		//State = Frame.checkResponseFrame(0);

		return State;
	}
	
	/**
	 * 
	 * @param stat
	 * @return
	 */
	int judgeErrLevel(InstaxStatus stat) {
		int ret;

		// 0:ƒGƒ‰[‚È‚µ
		// 1:ˆ—Œp‘±
		// 2:ˆ—’†Ž~
		
		//@’萔‚¶‚á‚È‚¢‚Ì‚Åswitch•¶–³—
		if( stat.ErrCode == ErrCode.RET_OK ) {
			ret = 0;
		}
		else if( stat.ErrCode == ErrCode.E_FILM_EMPTY 
				|| stat.ErrCode == ErrCode.E_BATTERY_EMPTY
				|| stat.ErrCode == ErrCode.E_CAM_POINT
				|| stat.ErrCode == ErrCode.E_MOTOR 
				|| stat.ErrCode == ErrCode.E_COVER_OPEN
				|| stat.ErrCode == ErrCode.E_PI_SENSOR) {
			ret = 1;
		}
		else {
			ret = 2;
		}
		return ret;
	}

	/**
	 * 
	 * @param newPassword
	 * @param oldPassword
	 * @return
	 */
	InstaxStatus InstaxChangePassword(int newPassword, int oldPassword) {
		InstaxLog.putLogToSD("NewPass:"+String.valueOf(newPassword));
		InstaxLog.putLogToSD("OldPass:"+String.valueOf(oldPassword));
		// ‹ŒƒpƒXƒ[ƒh‚ª•sˆê’v
		//if( Param.Password != oldPassword && Param.Password != -1 ) {
		//	State.setInstaxStatus(InstaxState.ST_BUSY,ErrCode.E_UNMATCH_PASS);
		//	return State;
		//}
		
		NetworkCommunication Sock = new NetworkCommunication();
		NetworkFrameData Frame = new NetworkFrameData();
		ErrCode err = ErrCode.RET_OK;
		int DataSize = 4;
		byte[] Data = new byte[DataSize];
		short Sid = 0xB6;
		
		// ƒf[ƒ^ì¬
		Data[0] = 0x00;
		Data[1] = 0x00;
		Data[2] = (byte)((newPassword >> 8) & 0xFF);
		Data[3] = (byte)((newPassword >> 0) & 0xFF);
		Frame.CreateSndData( UID, Sid, Data, DataSize, oldPassword );
		// ‘—ŽóM
		err = Sock.SndRcvData( Param, Frame );
		if( err != ErrCode.RET_OK) {
			State.setInstaxStatus(InstaxState.ST_BUSY,err);
			return State;
		}
		// ŽóMƒf[ƒ^ƒ`ƒFƒbƒN
		State = Frame.checkResponseFrame(0);
		if( judgeErrLevel(State) >= EMERGENCY_ERR_LEVEL ) {
			return State;
		}
		
		// ƒpƒXƒ[ƒh•ÏX
		Param.setPassword(newPassword);
		return State;
	}

	/**
	 * 
	 * @param filePath
	 * @return
	 */
	boolean InstaxSetOutputLog(String filePath) {
		return InstaxLog.SetLogPath(filePath);
	}
}

NetworkCommunicationParam.java

package com.Instax.sdk;

class NetworkCommunicationParam {
	static final String def_IpAddress = "192.168.0.251"; 
	static final int def_Port = 8080;
	static final int def_SndTimeOut = 3000;
	static final int def_RcvTimeOut =3000;
	static final int def_RetryCnt = 3;
	static final int def_MaxFrameSize = 480;
	static final int def_DelayTime = 0;
	static final int def_IMAGE_Format = 2;	// default JPG
	static final int def_IMAGE_Option = 0;
	static final int def_Password = 1111;
	
	String IpAddress;
	int Port;
	int SndTimeOut;
	int RcvTimeOut;
	int RetryCnt;
	int MaxFrameSize;
	int DelayTime;
	int IMAGE_Format;
	int IMAGE_Option;
	int Password;
	
	NetworkCommunicationParam() {
		IpAddress = def_IpAddress;
		Port = def_Port;
		SndTimeOut = def_SndTimeOut;
		RcvTimeOut = def_RcvTimeOut;
		RetryCnt = def_RetryCnt;
		MaxFrameSize = def_MaxFrameSize;
		DelayTime = def_DelayTime;
		IMAGE_Format = def_IMAGE_Format;
		IMAGE_Option = def_IMAGE_Option;
		Password = def_Password;
	}
	
	void setPassword(int pass) {
		if( -1 <= pass && pass <= 9999 ) {
			this.Password = pass;
		}
		else {
			this.Password = def_Password;
		}
	}
	/**
	 * setNetworkParam
	 * @param ipAddress
	 * @param port
	 */
	void setNetworkParam(String ipAddress, int port) {
		if( ipAddress != null ) {
			this.IpAddress = ipAddress;
		}
		if( 0 <= port && port <= 65535 ) {
			this.Port = port;
		}
		else {
			this.Port = def_Port;	// ”͈͊O‚͏‰Šú’l‚ð“ü‚ê‚é
		}
	}
	
	/**
	 * setCommunicationParam
	 * @param sndTimeout
	 * @param rcvTimeout
	 * @param retryCnt
	 */
	void setCommunicationParam(int sndTimeout, int rcvTimeout, int retryCnt) {
		if(sndTimeout < 0 || rcvTimeout < 0 || retryCnt < 0) {
			this.SndTimeOut = def_SndTimeOut;
			this.RcvTimeOut = def_RcvTimeOut;
			this.RetryCnt = def_RetryCnt;
		}
		else {
			this.SndTimeOut = sndTimeout;
			this.RcvTimeOut = rcvTimeout;
			this.RetryCnt = retryCnt;
		}
	}
	
	/**
	 * 
	 * @param sndMaxSize
	 * @param delayTime
	 */
	void setDebugParam(int maxDataSize, int delayTime, int jpgFlg, int jpgOpt) {
		final int SND_BUF_SIZE = 1024*64;
		if( maxDataSize > SND_BUF_SIZE-1-4-NetworkFrameData.MIN_REQ_FRAME_SIZE ) {
			this.MaxFrameSize = SND_BUF_SIZE-1-4-NetworkFrameData.MIN_REQ_FRAME_SIZE;
		}
		else if( maxDataSize < 1 ) {
			this.MaxFrameSize = def_MaxFrameSize;
		}
		else {
			this.MaxFrameSize = maxDataSize;
		}
		
		if( delayTime < 0 ) {
			this.DelayTime = def_DelayTime;
		}
		else {
			this.DelayTime = delayTime;
		}
		
		if( jpgFlg == 1 || jpgFlg == 2 ) {
			this.IMAGE_Format = jpgFlg;
		}
		else {
			this.IMAGE_Format = def_IMAGE_Format;
		}
		
//		if( jpgOpt > 0x0B && jpgOpt != 0x10 ) {
//			this.IMAGE_Option = 0x00;
//		}
//		else {
		//this.IMAGE_Option = jpgOpt;
//		}
	}
	
}

NetworkCommunicationSndImageThread.java

package com.Instax.sdk;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.InetSocketAddress;
import java.net.Socket;
import java.net.SocketTimeoutException;
import java.net.UnknownHostException;
import java.nio.channels.IllegalBlockingModeException;
import java.util.Arrays;

import android.util.Log;

import com.Instax.sdk.InstaxStatus.ErrCode;
import com.Instax.sdk.InstaxStatus.InstaxState;

class NetworkCommunicationSndImageThread extends Thread {
    private NetworkCommunicationParam param;
    private byte[] AllSndData;			// ‘—M‚·‚é‘Sƒf[ƒ^
    private InstaxCallBack sndCallback;	// ‘—MŠ®—¹ƒR[ƒ‹ƒoƒbƒN
    private InstaxCallBack cancelCallback;	// ‘—M’†Ž~ƒR[ƒ‹ƒoƒbƒN
    private int SndMaxSize;				// ‚P‰ñ‚É‘—‚éÅ‘åƒTƒCƒY
    private short Sid;
    private int UID;
    volatile private int Prog;			// i’»
    volatile private boolean cancelFlg;	// ƒLƒƒƒ“ƒZƒ‹ƒtƒ‰ƒO
    private int DelayTime;

    /**
     * 
     * @param param
     * @param sid
     * @param sndData
     * @param length
     * @param sndMaxSize
     * @param sndFinish
     */
    NetworkCommunicationSndImageThread(NetworkCommunicationParam param, int uid, short sid, byte[] sndData, int sndMaxSize, InstaxCallBack sndFinish) {
        this.param = param;
        this.AllSndData= sndData; 
        this.sndCallback = sndFinish;
        this.SndMaxSize = sndMaxSize;
        this.Sid = sid;
        this.Prog = 0;
        this.cancelFlg = false;
        this.cancelCallback = null;
        this.UID = uid;
        this.DelayTime = param.DelayTime;	// ms
    }

    /**
     * getProgress
     * @return
     */
    int getProgress() {
    	return Prog;
    }
    
    /**
     * 
     * @param cancelFinish
     */
    void SndImageCancel(InstaxCallBack cancelFinish) {
    	cancelCallback = cancelFinish;
		cancelFlg = true;
	}
    
    /**
     * 
     * @return
     */
    /*
    private InstaxStatus ModeReset() {
    	InstaxStatus state = new InstaxStatus();
    	NetworkCommunication Sock = new NetworkCommunication();
		NetworkFrameData Frame = new NetworkFrameData();
		int DataSize = 1;
		byte[] Data = new byte[DataSize];
		short Sid = 0xB3;
		ErrCode err = ErrCode.RET_OK;
		
		// ‘—ŽóM
		Data[0] = 0;
		Frame.CreateSndData( UID, Sid, Data, DataSize );
		err = Sock.SndRcvData( param, Frame );
		if( err != ErrCode.RET_OK ) {
			state.setInstaxStatus(InstaxState.ST_BUSY, err);
			return state;
		}
		// ŽóMƒf[ƒ^ƒ`ƒFƒbƒN
		state = Frame.checkResponseFrame(0);

		return state;
	}
    */
    // 0x51
    private InstaxStatus TransferStart() {
    	InstaxStatus state = new InstaxStatus();
    	NetworkCommunication Sock = new NetworkCommunication();
		NetworkFrameData Frame = new NetworkFrameData();
 		int DataSize = 12;
 		byte[] Data = new byte[DataSize];
 		int imgSize = AllSndData.length;
 		short Sid = 0x51;
 		ErrCode err = ErrCode.RET_OK;
 		
 		Data[0] = (byte)param.IMAGE_Format;		// ‰æ‘œƒtƒH[ƒ}ƒbƒg
 		Data[1] = (byte)param.IMAGE_Option;		// pic opt
 		Data[2] = (byte)(((int)imgSize >> 24) & 0xFF);		// size
 		Data[3] = (byte)(((int)imgSize >> 16) & 0xFF);
 		Data[4] = (byte)(((int)imgSize >> 8) & 0xFF);;
 		Data[5] = (byte)(((int)imgSize >> 0) & 0xFF);;		
 		Data[6] = 0x00;		// jpg param
 		Data[7] = 0x00;
 		Data[8] = 0x00;
 		Data[9] = 0x00;
 		Data[10] = 0x00;	// reserve
 		Data[11] = 0x00;	// reserve
 		
 		// ‘—ŽóM
 		Frame.CreateSndData( UID, Sid, Data, DataSize, param.Password );
 		err = Sock.SndRcvData( param, Frame );
 		if( err != ErrCode.RET_OK ) {
 			state.setInstaxStatus(InstaxState.ST_BUSY, err);
 			return state;
 		}
 		state = Frame.checkResponseFrame( 0 );
 		
 		return state;
 	}
 		
    // 0x53
    private InstaxStatus TransferEnd() {
    	InstaxStatus state = new InstaxStatus();
    	NetworkCommunication Sock = new NetworkCommunication();
		NetworkFrameData Frame = new NetworkFrameData();
 		int DataSize = 0;
 		byte[] Data = new byte[DataSize];
 		short Sid = 0x53;
 		ErrCode err = ErrCode.RET_OK;
 		
 		// ‘—ŽóM
 		Frame.CreateSndData( UID, Sid, Data, DataSize, param.Password );
 		err = Sock.SndRcvData( param, Frame );
 		if( err != ErrCode.RET_OK ) {
 			state.setInstaxStatus(InstaxState.ST_BUSY, err);
 			return state;
 		}
 		//state = Frame.checkResponseFrame( 4 );
 		state = Frame.checkResponseFrame( 0 );
 		//if( state.ErrCode != ErrCode.RET_OK ) {
		//	return state;
		//}
		// ‰æ‘œƒf[ƒ^ƒ`ƒFƒbƒNƒTƒ€‚È‚ñ‚Ä‚à‚Ì‚Í‚È‚©‚Á‚½
		//int picSum = 0;
        //for(int i=0; i<AllSndData.length; i++) {
        //	picSum += ((int)AllSndData[i] & 0xFF);
        //}
        //picSum = picSum & 0xFFFFFFFF;
		//if( Frame.getResponselongData(0) != picSum ) {
		//	// ‰æ‘œƒf[ƒ^ƒ`ƒFƒbƒNƒTƒ€•sˆê’v
		//	state.setInstaxStatus(InstaxState.ST_BUSY, ErrCode.E_RCV_FRAME);
		//	Log.e("thread", "picSum Error:"+String.valueOf(Frame.getResponseShortData(0)));
		//	Log.e("thread", "picSum Error:"+String.valueOf(picSum));
		//}
 		return state;
 	}
    
	@Override
    public void run() {
		Log.d("thread", "thread start");
		InstaxStatus state = new InstaxStatus();
		NetworkFrameData Frame = new NetworkFrameData();
		Socket socket;
		OutputStream os;
		InputStream is;
		int i, loop, lastSize, seqCnt;
		byte[] data = new byte[SndMaxSize+4];	// ƒV[ƒPƒ“ƒXƒf[ƒ^•ª+4
		boolean finishFlg = true;
		ErrCode err = ErrCode.RET_OK;
		boolean RcvFlg = false;
		
		loop = (int)(AllSndData.length/SndMaxSize);
		lastSize = (int)(AllSndData.length%SndMaxSize);
		
		Log.d("thread","AllSndDataLength:"+String.valueOf(AllSndData.length));
		Log.d("thread","SndMaxSize:"+String.valueOf(SndMaxSize));
		Log.d("thread","loop:"+String.valueOf(loop));
		Log.d("thread","lastSize:"+String.valueOf(lastSize));
		Log.d("thread", "SendTimeout:"+String.valueOf(param.SndTimeOut));
		Log.d("thread", "RecvTimeout:"+String.valueOf(param.RcvTimeOut));
		Log.d("thread", "Retry:"+String.valueOf(param.RetryCnt));
				
		seqCnt = 0;
		Prog = 0;
		// ‘—MƒLƒƒƒ“ƒZƒ‹
		if( cancelFlg == true && cancelCallback != null )
		{
			Log.d("thread", "SndImageCanncel");
			state.setInstaxStatus(InstaxState.ST_IDLE, ErrCode.RET_OK);
			cancelCallback.FinishCallBack(state);
			//ModeReset();
			return;
		}
		// ˜A‘±‘—M
		// Nullƒ`ƒFƒbƒN
        if( param == null || Frame == null ) {
        	Log.e("thread", "NullObject");
    		state.setInstaxStatus(InstaxState.ST_BUSY, ErrCode.E_CONNECT);
    		sndCallback.FinishCallBack(state);
    		//ModeReset();
    		return;
        }
        
        // 0x51 ‘—M
        state = TransferStart();
        if( state.InstaxState != InstaxState.ST_IDLE || state.ErrCode != ErrCode.RET_OK ) {
        	sndCallback.FinishCallBack(state);
        	//ModeReset();
    		return;
        }
        
		try {
			// ƒ\ƒPƒbƒgì¬
			socket = new Socket();
			// Ú‘±
			socket.connect(new InetSocketAddress(param.IpAddress,param.Port),param.SndTimeOut);
			os = socket.getOutputStream();
    		is = socket.getInputStream();
    		Log.d("thread", "Connect Socket");
			
    		// 0x52‘—M
			for( i=0; i<loop; i++) {
				if( cancelFlg == true ) {
					Log.d("thread", "SndImageCanncel");
					break;
				}
				data[0] = (byte)((seqCnt >> 24) & 0xFF);
				data[1] = (byte)((seqCnt >> 16) & 0xFF);
				data[2] = (byte)((seqCnt >> 8) & 0xFF);
				data[3] = (byte)((seqCnt >> 0) & 0xFF);
				System.arraycopy(AllSndData, i*SndMaxSize, data, 4, SndMaxSize);
				Frame.CreateSndData(UID, Sid, data, SndMaxSize+4, param.Password);
///////////////////////////////////////////////////////////////////////////////////////////////////////////
// ŠÖ”‰»‚·‚é‚Æsocket’ʐM‚ª‚¤‚Ü‚­‚¢‚©‚È‚­‚È‚é‚̂Ńxƒ^‘‚«‚·‚é
				for( int retry=0; retry<=param.RetryCnt; retry++) {
					if( cancelFlg == true ) {
						Log.d("thread", "SndImageCanncel");
						break;
					}
	        		// ƒf[ƒ^‘—M
					if( !socket.isConnected() ) {
						Log.d("thread", "socket disconnect");
						// ƒ\ƒPƒbƒgì¬
						socket = new Socket();
						// Ú‘±
						socket.connect(new InetSocketAddress(param.IpAddress,param.Port),param.SndTimeOut);
						os = socket.getOutputStream();
			    		is = socket.getInputStream();
					}
	        		os.write(Frame.getSndData(), 0, Frame.getSndSize());
	        		os.flush();
		   
	        		// “ǂݍž‚Þ‚Ü‚Å‘Ò‹@
	        		long s = System.currentTimeMillis();
	        		while(true) {
	        			if( is.available() != 0 ) {
	        				// ŽóM
	        				RcvFlg = true;
	        				break;
	        			}
	        			if( (System.currentTimeMillis() - s) >= param.RcvTimeOut ) {
	        				// ŽóMƒ^ƒCƒ€ƒAƒEƒg
	        				RcvFlg = false;
	        				os.close();
	        				is.close();
	        				socket.close();
	        				socket = new Socket();
							// ÄÚ‘±
							socket.connect(new InetSocketAddress(param.IpAddress,param.Port),param.SndTimeOut);
							os = socket.getOutputStream();
				    		is = socket.getInputStream();
	        				break;
	        			}
	        		}
		        	if( RcvFlg == true ) {
		        		// “ǂݍž‚ñ‚¾‚à‚Ì‚ð‘‚«‚¾‚·
		        		Frame.setRcvSize(is.available());
		        		Frame.setRcvData(new byte[Frame.getRcvSize()]);
		        		is.read(Frame.getRcvData(), 0, Frame.getRcvSize());
		        	}
	        		if( RcvFlg == false ) {
	        			Log.e("SndRcvData", "RcvTimeOut");
	        			err = ErrCode.E_RCV_TIMEOUT;
	        			continue;
	        		}
		        	err = ErrCode.RET_OK;
		        	break;
		        }// retry
///////////////////////////////////////////////////////////////////////////////////////////////////////////
				if( err != ErrCode.RET_OK ) {
					// ‘—ŽóMƒGƒ‰[
					finishFlg = false;
					state.setInstaxStatus(InstaxState.ST_BUSY, err);
					Log.e("thread", "SndRcvData Error:"+err.toString());
					break;
				}
				state = Frame.checkResponseFrame(4);
				if( state.ErrCode != ErrCode.RET_OK ) {
					// ƒŒƒXƒ|ƒ“ƒXƒGƒ‰[
					finishFlg = false;
					state.setInstaxStatus(InstaxState.ST_BUSY, state.ErrCode);
					Log.e("thread", "Response Error:"+state.ErrCode.toString());
					break;
				}
				if( Frame.getResponselongData(0) != seqCnt ) {
					// ƒV[ƒPƒ“ƒX•sˆê’v
					finishFlg = false;
					state.setInstaxStatus(InstaxState.ST_BUSY, ErrCode.E_RCV_FRAME);
					Log.e("thread", "Sequence Error:"+String.valueOf(seqCnt));
					break;
				}
				//Log.d("thread", "Sequence:"+String.valueOf(seqCnt));
				seqCnt++;
				if( lastSize > 0 ) {
					Prog = (i*100)/(loop+1);		// i’»—¦ŒvŽZ
				}
				else {
					Prog = (i*100)/(loop);
				}
				if( DelayTime > 0 ) {
					Thread.sleep(DelayTime);
				}
			}// loop
			
			// —]‚è‘—M
			if( finishFlg == true && lastSize > 0 && cancelFlg == false ) {
				Arrays.fill(data, (byte)0x00);
				data[0] = (byte)((seqCnt >> 24) & 0xFF);
				data[1] = (byte)((seqCnt >> 16) & 0xFF);
				data[2] = (byte)((seqCnt >> 8) & 0xFF);
				data[3] = (byte)((seqCnt >> 0) & 0xFF);
				System.arraycopy(AllSndData, i*SndMaxSize, data, 4, lastSize);
				//Frame.CreateSndData(UID, Sid, data, lastSize+4);
				// ’[”‚ª‚ ‚Á‚½ê‡‚Í’[”•ª‚¾‚¯‘—‚Á‚Ä‚¢‚½‚ª0–„‚߂ŃtƒŒ[ƒ€ƒTƒCƒY‚ð‡‚í‚¹‚邱‚Æ‚É‚È‚Á‚½
				Frame.CreateSndData(UID, Sid, data, SndMaxSize+4, param.Password);
///////////////////////////////////////////////////////////////////////////////////////////////////////////
// ŠÖ”‰»‚·‚é‚Æsocket’ʐM‚ª‚¤‚Ü‚­‚¢‚©‚È‚­‚È‚é‚̂Ńxƒ^‘‚«‚·‚é
				for( int retry=0; retry<=param.RetryCnt; retry++) {
					if( cancelFlg == true ) {
						Log.d("thread", "SndImageCanncel");
						break;
					}
					// ƒf[ƒ^‘—M
					if( !socket.isConnected() ) {
						// ƒ\ƒPƒbƒgì¬
						socket = new Socket();
						// Ú‘±
						socket.connect(new InetSocketAddress(param.IpAddress,param.Port),param.SndTimeOut);
						os = socket.getOutputStream();
			    		is = socket.getInputStream();
					}
					os.write(Frame.getSndData(), 0, Frame.getSndSize());
					os.flush();

					// “ǂݍž‚Þ‚Ü‚Å‘Ò‹@
					long s = System.currentTimeMillis();
					while(true) {
						if( is.available() != 0 ) {
							// ŽóM
							RcvFlg = true;
							break;
						}
						if( (System.currentTimeMillis() - s) >= param.RcvTimeOut ) {
							// ŽóMƒ^ƒCƒ€ƒAƒEƒg
							RcvFlg = false;
							os.close();
	        				is.close();
	        				socket.close();
	        				socket = new Socket();
							// ÄÚ‘±
							socket.connect(new InetSocketAddress(param.IpAddress,param.Port),param.SndTimeOut);
							os = socket.getOutputStream();
				    		is = socket.getInputStream();
				    		break;
						}
					}
					if( RcvFlg == true ) {
						// “ǂݍž‚ñ‚¾‚à‚Ì‚ð‘‚«‚¾‚·
						Frame.setRcvSize(is.available());
						Frame.setRcvData(new byte[Frame.getRcvSize()]);
						is.read(Frame.getRcvData(), 0, Frame.getRcvSize());
					}
					if( RcvFlg == false ) {
						Log.e("SndRcvData", "RcvTimeOut");
						err = ErrCode.E_RCV_TIMEOUT;
						continue;
					}
					err = ErrCode.RET_OK;
					break;
				}// retry
///////////////////////////////////////////////////////////////////////////////////////////////////////////
				if( err != ErrCode.RET_OK ) {
					// ‘—ŽóMƒGƒ‰[
					finishFlg = false;
					state.setInstaxStatus(InstaxState.ST_BUSY, err);
					Log.e("thread", "SndRcvData Error:"+err.toString());
				}
				state = Frame.checkResponseFrame(4); 
				if( state.ErrCode != ErrCode.RET_OK ) {
					// ƒŒƒXƒ|ƒ“ƒXƒGƒ‰[
					finishFlg = false;
					state.setInstaxStatus(InstaxState.ST_BUSY, state.ErrCode);
					Log.e("thread", "Response Error:"+state.ErrCode.toString());
				}
				if( Frame.getResponselongData(0) != seqCnt ) {
					// ƒV[ƒPƒ“ƒX•sˆê’v
					finishFlg = false;
					state.setInstaxStatus(InstaxState.ST_BUSY, ErrCode.E_RCV_FRAME);
					Log.e("thread", "Sequence Error:"+String.valueOf(seqCnt));
				}
				if( DelayTime > 0 ) {
					Thread.sleep(DelayTime);
				}
			}// 0x52‘—M
			
			// Ø’f
			os.close();
			is.close();
			socket.close();
			
			// 0x53 ‘—M
			if( finishFlg == true && cancelFlg == false ) {
				state = TransferEnd();
				if( state.InstaxState != InstaxState.ST_IDLE || state.ErrCode != ErrCode.RET_OK ) {
					finishFlg = false;
				}
			}
		} catch (SocketTimeoutException e) {		// ƒ\ƒPƒbƒgì¬Ž¸”s
			InstaxLog.putLogToSD("SocketTimeoutException");
    		Log.e("thread", "SocketTimeOut");
    		state.setInstaxStatus(InstaxState.ST_BUSY, ErrCode.E_MAKE_SOCKET);
    		finishFlg = false;
    	} catch (IllegalBlockingModeException e) {	// ƒCƒŠ[ƒKƒ‹ƒGƒ‰[
    		InstaxLog.putLogToSD("IllegalBlockingModeException");
    		Log.e("thread","IllegalBlockingMode");
    		state.setInstaxStatus(InstaxState.ST_BUSY, ErrCode.E_CONNECT);
    		finishFlg = false;
    	} catch (IllegalArgumentException e) {
    		InstaxLog.putLogToSD("IllegalArgumentException");
    		Log.e("thread", "IllegalArgument");	// ˆø”ˆÙí
    		state.setInstaxStatus(InstaxState.ST_BUSY, ErrCode.E_CONNECT);
    		finishFlg = false;
    	} catch (UnknownHostException e) {
    		InstaxLog.putLogToSD("UnknownHostException");
    		Log.e("thread", "UnknownHost");		// ƒzƒXƒg‚ªŒ©‚‚©‚ç‚È‚¢
    		state.setInstaxStatus(InstaxState.ST_BUSY, ErrCode.E_CONNECT);
    		finishFlg = false;
    	} catch (InterruptedException e) {
    		InstaxLog.putLogToSD("InterruptedException");
    		Log.e("thread", "InterruptedException");		// ƒzƒXƒg‚ªŒ©‚‚©‚ç‚È‚¢
    		state.setInstaxStatus(InstaxState.ST_BUSY, ErrCode.E_CONNECT);
    		finishFlg = false;
    	} catch (IOException e) {					// ‚»‚Ì‘¼
    		InstaxLog.putLogToSD("IOException " + e.getMessage());
    		Log.e("thread", "IOException " + e.getMessage());
    		state.setInstaxStatus(InstaxState.ST_BUSY, ErrCode.E_CONNECT);
    		finishFlg = false;
    	}
		// ƒXƒe[ƒ^ƒXƒZƒbƒg
		if( cancelFlg == true && cancelCallback != null ) {
			Prog = 0;
			state.setInstaxStatus(InstaxState.ST_IDLE, ErrCode.RET_OK);
			cancelCallback.FinishCallBack(state);
			Log.d("thread", "SndImageCanncel");
			//ModeReset();
			return;
		}
		if( finishFlg == true ) {
			Prog = 100;
			state.setInstaxStatus(InstaxState.ST_IDLE, ErrCode.RET_OK);
		}
		else {
			Prog = 0;
			//ModeReset();
		}
		// ƒR[ƒ‹ƒoƒbƒN
		sndCallback.FinishCallBack( state );
        Log.d("thread", "thread end");
    }
}

Hello,

I try to create a photobooth using rasberry Pi 2 and the Share SP-1, so i tried your code in order to understand how the protocol works, but sadly several classes are missing.

Do i need to decompile the official instax Application to get this classes?

Thx, in advance ;)

Hello Contra
I am also working on a similar app for the Instax and it would be great if you can share the additional classes
com.Instax.sdk.InstaxStatus.ErrCode
com.Instax.sdk.InstaxStatus.InstaxState

That will certainly help me a lot ... Thank you soooooooooo much advance

Henry