termsdriver.c

hid类usb对外设的驱动application

						if(strcmp(str1,"ICBC0")==0){
							str1[5]='0';
							str1[6]=str[18];
							if((strcmp(str1,"ICBC011")==0)||(strcmp(str1,"ICBC001")==0)){
								DeviceDetected=TRUE;
								GetDeviceCapabilities();
								PreparedForOverlappedTransfer();
							}else{
								//CloseHandle(TermsDriver(hcom));
							}
						}
				}
				if(strcmp(deviceType,"ICCard")==0){
					str1[4]=str[16];
					if(strcmp(str1,"ICBC3")==0){
						DeviceDetected=TRUE;
					    GetDeviceCapabilities();
					    PreparedForOverlappedTransfer();
					}
					else 
						if(strcmp(str1,"ICBC0")==0){
							str1[5]='0';
							str1[6]=str[19];
							if(str1[6]=='1'){
								DeviceDetected=TRUE;
								GetDeviceCapabilities();
								PreparedForOverlappedTransfer();
							}else{
								//CloseHandle(TermsDriver(hcom));
							}
						}
				}

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

//-------------------------------打开设备--------------------------------
JNIEXPORT jint JNICALL Java_TermsDriver_open(JNIEnv *env, jobject obj, 
												 jbyteArray deviceID,
												 jbyte port,
												 jbyte extport,
												 jint baudRate,
												 jbyte byteSize,
												 jbyte stopBit,
												 jbyte parityBit,
												 jboolean printFlag){
	char *buf;
	BOOL flag=(BOOL)printFlag;
	jbyte *abyte=(*env)->GetByteArrayElements(env,deviceID,NULL);
	int len=(*env)->GetArrayLength(env,(jarray)deviceID);
	buf=(char *)malloc(len+1);
	memset(buf,0x00,len+1);
	memcpy(buf,abyte,len);

	if(SearchDevices(buf,flag)){
		(*env)->ReleaseByteArrayElements(env,deviceID,abyte,0);
		free(buf);
		return 1;
	}
	else{
		(*env)->ReleaseByteArrayElements(env,deviceID,abyte,0);
		free(buf);
		return 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,size,tmpLen;
	jbyte *abyte=(*env)->GetByteArrayElements(env,sendData,NULL);
	unsigned char *buf;
	unsigned char OutputReport[256];

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

	size=Length;
	j=0;

	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);
		if(Result==0)
		{
			if(GetLastError()==ERROR_IO_PENDING)
			{

				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
			{
				free(buf);
				(*env)->ReleaseByteArrayElements(env,sendData,abyte,0);
				return -1;
			}
		}
		else
		{
			free(buf);
			(*env)->ReleaseByteArrayElements(env,sendData,abyte,0);
			return 1;
		}
	}else{
		NumberOfBytesWritten=0;
		memset(OutputReport,0x00,256);
		//指定数据从主机传向设备的时候，报告ID为0X00
		OutputReport[0]=0x00;
		memcpy(OutputReport+1,buf,size);
		ReportLength=Capabilities.OutputReportByteLength;

		//假如句柄分配失败，释放资源，返回。
		if(TermsDriver(hcom)==INVALID_HANDLE_VALUE||TermsDriver(hcom)==NULL){
			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);

			if(Result==0)
			{
				if(GetLastError()==ERROR_IO_PENDING)
				{
					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);
					}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
				{
					free(buf);
					(*env)->ReleaseByteArrayElements(env,sendData,abyte,0);
					return -1;
				}
			}
			else
			{
				j+=Capabilities.OutputReportByteLength;
				memset(OutputReport,0x00,sizeof(OutputReport));
				//报告ID指定为0x00，写的时候
				OutputReport[0]=0x00;
				memcpy(OutputReport+1,buf+j-(i+1),Capabilities.OutputReportByteLength);
			}
		}
		tmpLen=size-j;
		if(tmpLen>0)
		{
			Result=WriteFile(TermsDriver(hcom),
				OutputReport,
				Capabilities.OutputReportByteLength,
				&tmpLen,
				(LPOVERLAPPED)&HIDOverlappedWrite);

			if(Result==0)
			{
				if(GetLastError()==ERROR_IO_PENDING)
				{

					Result=WaitForSingleObject(WriteEventObject,1000);
					if(Result==WAIT_OBJECT_0){
						free(buf);
						//free(outputReport);
						(*env)->ReleaseByteArrayElements(env,sendData,abyte,0);
						return 1;
					}
					else{
						free(buf);
						//free(outputReport);
						(*env)->ReleaseByteArrayElements(env,sendData,abyte,0);
						//CloseHandle(TermsDriver(hcom));
						return -1;
					}
				}
				else
				{
					free(buf);
					(*env)->ReleaseByteArrayElements(env,sendData,abyte,0);
					return -1;
				}
			}
			else
			{
				
				free(buf);
				//free(outputReport);
				(*env)->ReleaseByteArrayElements(env,sendData,abyte,0);
				return 1;
			}

		}else{
			free(buf);
			//free(outputReport);
			(*env)->ReleaseByteArrayElements(env,sendData,abyte,0);
			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[1];
	int Timeout=(int)ioTimeout;
	DataLen=0;
	memset(TmpBuf,0,sizeof(TmpBuf));
	memset(InputReport,0,sizeof(InputReport));

	RetLen=(*env)->GetArrayLength(env,(jarray)recvData);
	buf=(char *)malloc(RetLen+1);
	memset(buf,0,RetLen);

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


		Result=ReadFile(TermsDriver(hcom),
			buf,
			RetLen,
			&NumberOfBytesRead,
			(LPOVERLAPPED)&HIDOverlappedRead);

		if(Result==0)
		{
			if(GetLastError()==ERROR_IO_PENDING)
			{

				Result=WaitForSingleObject(ReadEventObject,Timeout);
				if(Result==WAIT_OBJECT_0){

					len[0]=RetLen;
					(*env)->SetByteArrayRegion(env,recvData,0,RetLen,buf);
					(*env)->SetIntArrayRegion(env,length,0,1,len);
					free(buf);
					return 0;
				}else{
					if(Result==WAIT_TIMEOUT){
						free(len);
						free(buf);
						return -1;
					}else{
						free(len);
						free(buf);
						return -1;
					}
				}
			}
			else
			{
				free(len);
				free(buf);
				return -1;
			}
		}
		else
		{
			len[0]=RetLen;
			(*env)->SetByteArrayRegion(env,recvData,0,RetLen,buf);
			(*env)->SetIntArrayRegion(env,length,0,1,len);
			free(buf);
			return 0;
		}

	}else{
		memset(InputReport,0x00,256);
		//打开句柄失败
		if(TermsDriver(hcom)==INVALID_HANDLE_VALUE||(TermsDriver(hcom)==NULL)){
			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("dataLen is %d\n",DataLen);

				if(DataLen<Capabilities.InputReportByteLength-3){
					ResetEvent(ReadEventObject);
					memcpy(buf,&TmpBuf[2],DataLen);
					(*env)->SetByteArrayRegion(env,recvData,0,DataLen,buf);
					free(buf);
					printf("DataLen is %d\n",DataLen);
					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,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],
								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);

				(*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){
	if(TermsDriver(hcom)!=NULL)
		CloseHandle(TermsDriver(hcom));
	TermsDriver(hcom)=NULL;
}

JNIEXPORT jint JNICALL Java_TermsDriver_test(JNIEnv *env,jobject obj,jint i,jboolean bl){

	int ret=(int)i;
	BOOL b=(BOOL)bl;
	printf("%d,%d\n",ret,b);
	return ret;
}