Skip to content

Instantly share code, notes, and snippets.

@yocontra

yocontra/InstaxProtocol.java

Created July 7, 2015 07:32
Show Gist options
  • Save yocontra/d42a6668963b0c94c182 to your computer and use it in GitHub Desktop.
Save yocontra/d42a6668963b0c94c182 to your computer and use it in GitHub Desktop.
Download ZIP
Instax SP-1 Android Source
Raw
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);
}
}
Raw
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;
// }
}
}
Raw
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");
}
}
@AcmonCercopes
Copy link

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 ;)

@henryww
Copy link

henryww commented May 10, 2016

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

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment