termsdriver.c.bak

hid类usb对外设的驱动application

				else
					CloseHandle(TermsDriver(hcom));
			free(DetailData);
			}else
				LastDevice=TRUE;
			MemberIndex=MemberIndex+1;
		}while(LastDevice!=TRUE&&DeviceDetected!=TRUE);
		SetupDiDestroyDeviceInfoList(hDevInfo);
		return DeviceDetected;
	}
}

//-------------------------------打开设备--------------------------------
JNIEXPORT jbyte JNICALL Java_TermsDriver_open(JNIEnv *env, jobject obj, 
												 jbyteArray manufacturerStr,
												 jbyte port,
												 jbyte extport,
												 jint baudRate,
												 jbyte byteSize,
												 jbyte stopBit,
												 jbyte parityBit,
												 jboolean printFlag){
	jbyte *abyte;
	int length;
	byte *buf;
	BOOL flag=(BOOL)printFlag;

	length=(*env)->GetArrayLength(env,(jarray)manufacturerStr);
	abyte=(*env)->GetByteArrayElements(env,manufacturerStr,NULL);
	buf=(byte *)malloc(length+1);

	memset(buf,0,length+1);
	memcpy(buf,abyte,length);

	if(SearchDevices(buf,flag)){
		(*env)->ReleaseByteArrayElements(env,manufacturerStr,abyte,0);
		free(buf);
		return (jbyte)1;
	}
	else{
		(*env)->ReleaseByteArrayElements(env,manufacturerStr,abyte,0);
		free(buf);
		return (jbyte)0;
	}
}
//------------------------------------------------------------------------

//----------往设备写入数据，HID设备与打印机类设备写数据的方法稍稍有些差异-
JNIEXPORT jint JNICALL Java_TermsDriver_write(JNIEnv *env,jobject obj,
												jbyte port,
												 jbyteArray sendData,
												 jint length,
												 jboolean printFlag){
	BOOL flag=(BOOL)printFlag;
	int Length=(int)length;
	int NumberOfBytesWritten=0;
	int Result,ReportLength,i,j;
	jbyte *abyte=(*env)->GetByteArrayElements(env,sendData,NULL);
	char *buf;
	char OutputReport[256];

	buf=(char *)malloc(Length+1);
	memset(buf,0x00,sizeof(buf));
	memcpy(buf,abyte,Length);

	if(flag==TRUE){
		if(TermsDriver(hcom)==NULL){
			free(buf);
			(*env)->ReleaseByteArrayElements(env,sendData,abyte,0);
			return -1;
		}
		//打开句柄失败
		if(TermsDriver(hcom)==INVALID_HANDLE_VALUE){
			free(buf);
			CloseHandle(TermsDriver(hcom));
			return -1;
		}
		Result=WriteFile(TermsDriver(hcom),
			buf,
			Length,
			&NumberOfBytesWritten,
			(LPOVERLAPPED) &HIDOverlappedWrite);

		Result=WaitForSingleObject(WriteEventObject,1000);
		if(Result==WAIT_OBJECT_0){
			free(buf);
			(*env)->ReleaseByteArrayElements(env,sendData,abyte,0);
			return 1;
		}else{
			if(Result=WAIT_TIMEOUT){
				free(buf);
				(*env)->ReleaseByteArrayElements(env,sendData,abyte,0);
				CloseHandle(TermsDriver(hcom));
				return -1;
			}else{
				free(buf);
				(*env)->ReleaseByteArrayElements(env,sendData,abyte,0);
				CloseHandle(TermsDriver(hcom));
				return -1;
			}
		}
	}else{
		NumberOfBytesWritten=0;
		memset(OutputReport,0x00,256);
		//指定数据从主机传向设备的时候，报告ID为0X00
		OutputReport[0]=0x00;
		ReportLength=Capabilities.OutputReportByteLength;

		//假如句柄分配失败，释放资源，返回。
		if(TermsDriver(hcom)==INVALID_HANDLE_VALUE){
			free(buf);
			(*env)->ReleaseByteArrayElements(env,sendData,abyte,0);
			CloseHandle(TermsDriver(hcom));
			return -1;
		}

		//报告长度为实际数据长度＋报告ID的长度(1)，因此传递的次数
		//为总长度/实际数据的长度(报告长度－1)，采用非阻塞方式写数据
		//需要有超时判断
		for(i=0;i<Length/(ReportLength-1);i++){
			Result=WriteFile(TermsDriver(hcom),
				OutputReport,
				Capabilities.OutputReportByteLength,
				&NumberOfBytesWritten,
				(LPOVERLAPPED) &HIDOverlappedWrite);

			Result=WaitForSingleObject(WriteEventObject,1000);
			if(Result==WAIT_OBJECT_0){
				j+=Capabilities.OutputReportByteLength;
				memset(OutputReport,0x00,sizeof(OutputReport));
				//报告ID指定为0x00，写的时候
				OutputReport[0]=0x00;
				memcpy(OutputReport+1,buf+j-(i+1),Capabilities.OutputReportByteLength);
				//printf("%s\n",outputReport+1);
			}else{
				if(Result==WAIT_TIMEOUT){
					free(buf);
					(*env)->ReleaseByteArrayElements(env,sendData,abyte,0);
					CloseHandle(TermsDriver(hcom));
					return -1;
				}else{
					free(buf);
					(*env)->ReleaseByteArrayElements(env,sendData,abyte,0);
					CloseHandle(TermsDriver(hcom));
					return -1;
				}
			}
		}
		return 1;
	}
}
//---------------------------------------------------------------------------

//--------读出数据，HID设备与打印类设备稍稍有些不一致------------------------
JNIEXPORT jint JNICALL Java_TermsDriver_read(JNIEnv *env,jobject obj,
											 jbyte port,
												jbyteArray recvData,
												jintArray length,
												jint ioTimeout,
												jboolean printFlag){
	BOOL flag=(BOOL)printFlag;
	int DataLen,RetLen,Result,NumberOfBytesRead,i;
	unsigned char TmpBuf[256],InputReport[256];
	unsigned char *buf;
	int *len;
	int Timeout=(int)ioTimeout;

	DataLen=0;
	memset(TmpBuf,0,sizeof(TmpBuf));
	memset(InputReport,0,sizeof(InputReport));
	RetLen=(*env)->GetArrayLength(env,(jarray)length);
	len=(int *)malloc(RetLen);
	memset(len,0,RetLen);
	RetLen=(*env)->GetArrayLength(env,(jarray)recvData);
	buf=(char *)malloc(RetLen);
	memset(buf,0,RetLen);

	if(flag==TRUE){
		if(TermsDriver(hcom)==NULL){
			free(len);
			free(buf);
			return -1;
		}
		//打开句柄失败
		if(TermsDriver(hcom)==INVALID_HANDLE_VALUE){
			free(len);
			free(buf);
			CloseHandle(TermsDriver(hcom));
			return -1;
		}
		Result=ReadFile(TermsDriver(hcom),
			buf,
			RetLen,
			&NumberOfBytesRead,
			(LPOVERLAPPED)&HIDOverlappedWrite);

		Result=WaitForSingleObject(ReadEventObject,Timeout);
		if(Result==WAIT_OBJECT_0){
			len[0]=sizeof(buf);
			(*env)->SetIntArrayRegion(env,length,0,1,len);
			free(len);
			free(buf);
			return 0;
		}else{
			if(Result==WAIT_TIMEOUT){
				free(len);
				free(buf);
				return -1;
			}else{
				free(len);
				free(buf);
				return -1;
			}
		}

	}else{
		//打开句柄失败
		if(TermsDriver(hcom)==INVALID_HANDLE_VALUE){
			free(len);
			free(buf);
			CloseHandle(TermsDriver(hcom));
			return -1;
		}

		//以非阻塞方式打开设备，读取内容
		Result=ReadFile(TermsDriver(hcom),
			InputReport,
			Capabilities.InputReportByteLength,
			&NumberOfBytesRead,
			(LPOVERLAPPED)&HIDOverlappedRead);

 
		Result=WaitForSingleObject(ReadEventObject,Timeout);
		if(Result==WAIT_TIMEOUT){
			free(len);
			free(buf);
			CloseHandle(TermsDriver(hcom));
			return -1;
		}else{
			if(Result==WAIT_OBJECT_0){

				memcpy(TmpBuf,&InputReport[1],Capabilities.InputReportByteLength-1);

				memset(InputReport,0,sizeof(InputReport));
				DataLen=TmpBuf[0]*256+TmpBuf[1];
				len[0]=DataLen;
				(*env)->SetIntArrayRegion(env,length,0,1,len);
				//printf("%d",dataLen);

				if(DataLen<Capabilities.InputReportByteLength-3){
					ResetEvent(ReadEventObject);
					memcpy(buf,&TmpBuf[2],DataLen);
					(*env)->SetByteArrayRegion(env,recvData,0,DataLen,buf);
					free(len);
					free(buf);
					return DataLen;
				}
				for(i=1;i<(DataLen+2)/(Capabilities.InputReportByteLength-1);i++){
					ResetEvent(ReadEventObject);
					Result=ReadFile(TermsDriver(hcom),
						InputReport,
						Capabilities.InputReportByteLength,
						&NumberOfBytesRead,
						(LPOVERLAPPED)&HIDOverlappedRead);
					Result=WaitForSingleObject(ReadEventObject,1000);
					if(Result==WAIT_TIMEOUT){
						free(len);
						free(buf);
						CloseHandle(TermsDriver(hcom));
						return -1;
					}else{
						if(Result==WAIT_OBJECT_0){
							memcpy(TmpBuf+(Capabilities.InputReportByteLength-1)*i,
								&InputReport[1],
								Capabilities.InputReportByteLength-1);
							memset(InputReport,0,sizeof(InputReport));
						}else{
							free(len);
							free(buf);
							CloseHandle(TermsDriver(hcom));
							return -1;
						}
					}
				}
				if((DataLen+2)%(Capabilities.InputReportByteLength-1)){
					ResetEvent(ReadEventObject);
					Result = ReadFile (TermsDriver(hcom), 
						InputReport,
						Capabilities.InputReportByteLength, 
						&NumberOfBytesRead,
						(LPOVERLAPPED) &HIDOverlappedRead);
					Result=WaitForSingleObject(ReadEventObject,Timeout);
					if(Result==WAIT_TIMEOUT){
						free(len);
						free(buf);
						CloseHandle(TermsDriver(hcom));
						return -1;
					}else{
						if(Result==WAIT_OBJECT_0){
							memcpy(TmpBuf+(Capabilities.InputReportByteLength-1)*i,&InputReport[1],(DataLen+2)%(Capabilities.InputReportByteLength-1));
							memset(InputReport,0,sizeof(InputReport));
						}else{
							free(len);
							free(buf);
							CloseHandle(TermsDriver(hcom));
							return -1;
						}
					}
				}
				memcpy(buf,TmpBuf+2,DataLen);
				//printf("%d\n",dataLen);
				//printf("%s\n",tmpBuf+2);
				//printf("%s",buf);
				(*env)->SetByteArrayRegion(env,recvData,0,DataLen,buf);
				free(buf);
				free(len);
				return DataLen;
			}
		}
		return DataLen;

	}
}

JNIEXPORT void JNICALL Java_TermsDriver_close(JNIEnv *env,jobject obj){
	CloseHandle(TermsDriver(hcom));
}