安卓Android Studio读写FM1208CPU卡源码

本示例使用的发卡器：https://item.taobao.com/item.htm?spm=a1z10.5-c-s.w4002-21818769070.11.6c46789elLwMzv&id=615391857885 

package com.usbreadertest;

import androidx.appcompat.app.AppCompatActivity;

import android.os.Bundle;

import android.view.MenuItem;
import android.view.View;
import android.widget.Button;
import android.widget.CheckBox;
import android.widget.EditText;
import android.widget.Spinner;
import android.widget.TextView;

import com.reader.ourmifare;
public class CpuCardActivity extends AppCompatActivity {
    private TextView tv;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_cpu_card);
        androidx.appcompat.widget.Toolbar toolbar=findViewById(R.id.toolbar);
        setSupportActionBar(toolbar);

        tv = findViewById(R.id.sample_text);
        tv.setText("操作结果");

        Spinner spls = findViewById(R.id.spin_SelRWauthkey);
        spls.setSelection(1);
    }

    @Override
    public void onBackPressed(){
        super.onBackPressed();
        finish();
    }

    @Override
    public boolean onOptionsItemSelected(MenuItem item) {
        if(item.getItemId()==android.R.id.home){
            finish();
            return true;
        }
        return super.onOptionsItemSelected(item);
    }

    public void retmain(View view)
    {
        finish();
    }


    public void cpu_request(View view){
        byte status;                         //存放返回值
        byte[] mypiccserial = new byte[4];   //4字节设备编号
        byte[] myparam = new byte[4];        //4字节卡参数
        byte[] myver= new byte[1];
        byte[] mycode= new byte[1];

        TextView ctrcarduid;
        ctrcarduid = findViewById(R.id.textcarduid);
        ctrcarduid.setText("");

        tv = findViewById(R.id.sample_text);
        tv.setText("");

        status =ourmifare.cpurequest(mypiccserial,myparam, myver, mycode);
        if (status == 0 || status == 52) {
            ourmifare.pcdbeep(38);
            String serialnumber = "";
            for (int i = 0; i < 4; i++) {
                String bytestr = "00" + Integer.toHexString(mypiccserial[i] & 0xff);
                serialnumber = serialnumber + bytestr.substring(bytestr.length() - 2, bytestr.length());
            }
            ctrcarduid.setText(serialnumber);
            tv.setText("CPU卡已激活，卡号:"+serialnumber);
        } else {
            PrintErrInf(status);   //返回代码提示
        }
    }

    public void cpu_rsinit(View view){
        byte status;                         //存放返回值
        byte[] mypicckey = new byte[16];     //卡片认证密码,16进制，最好不要随便修改，此密码不影响数据安全
        byte mykeylen = 16 ;                 //卡片密码长度
        int  spacesize;                      //应用空间字节大小(要大于所有文件总和)，根据不同容量的卡设不同值
        byte emptycard;                      //初始化前是否清空卡内数据，取值1将先清空卡，取值为0不清空现有数据

        String cardkeystr;
        CheckBox ctrcheck;
        EditText ctrcardkey;
        EditText ctrspace;

        ctrcheck=findViewById(R.id.checkcleckcard) ;
        if(ctrcheck.isChecked()) {
            emptycard=1;
        }else {emptycard=0;}

        ctrspace=findViewById(R.id.textusespace) ;
        spacesize=Integer.parseInt(ctrspace.getText().toString().trim());

        ctrcardkey=findViewById(R.id.cardkey) ;
        cardkeystr=ctrcardkey.getText().toString().trim();
        if (cardkeystr.length() < 32)
        {
            tv.setText("卡密钥是32位16进制数据，请输入正确的卡片密钥!");
            return;
        }else {
            for (int i = 0; i < 16; i++) {
                mypicckey[i] = (byte) Integer.parseInt(cardkeystr.substring(i * 2, i * 2 + 2), 16);//只有用Integer.parseInt才能杜绝大于128时的错误
            }
        }

        status =ourmifare.cpursinit(emptycard, mypicckey, mykeylen, spacesize);
        if (status == 0 ) {
            ourmifare.pcdbeep(38);
            tv.setText("初始化卡成功！" );
        } else {
            PrintErrInf(status);   //返回代码提示
        }
    }

    public void cpu_rseasyfileadd(View view){
        byte status;                         //存放返回值
        byte RKLen = 16 ;                    //文件 只读权限密码 长度
        byte[] RFilekey = new byte[RKLen];   //文件 只读权限密码
        byte WKLen = 16 ;                    //文件 读写权限密码 长度
        byte[] WFilekey = new byte[WKLen];   //文件 读写权限密码，此权限高，可认证此密码修改只读密码，要记住文件密码

        Spinner spls = findViewById(R.id.spin_SelCreatefilenum);
        byte FileIndex = (byte)(spls.getSelectedItemId());   //指定文件号

        EditText ctrfilesize = findViewById(R.id.textfileszie);  //文件大小
        int FileSize=Integer.parseInt(ctrfilesize.getText().toString().trim());

        EditText ctrreadkey=findViewById(R.id.readkey) ;
        String readkeystr=ctrreadkey.getText().toString().trim();
        if (readkeystr.length() < 32)
        {
            tv.setText("文件只读密钥是32位16进制数据，请输入正确的只读密钥!");
            return;
        }else {
            for (int i = 0; i < 16; i++) {
                RFilekey[i] = (byte) Integer.parseInt(readkeystr.substring(i * 2, i * 2 + 2), 16);//只有用Integer.parseInt才能杜绝大于128时的错误
            }
        }

        EditText ctrwritekey=findViewById(R.id.writekey) ;
        String writekeystr=ctrwritekey.getText().toString().trim();
        if (writekeystr.length() < 32)
        {
            tv.setText("文件读写密钥是32位16进制数据，请输入正确的读写密钥!");
            return;
        }else {
            for (int i = 0; i < 16; i++) {
                WFilekey[i] = (byte) Integer.parseInt(writekeystr.substring(i * 2, i * 2 + 2), 16);//只有用Integer.parseInt才能杜绝大于128时的错误
            }
        }

        status =ourmifare.cpursfileadds(FileIndex, RFilekey, RKLen, WFilekey, WKLen, FileSize) ;  //
        if (status == 0 ) {
            ourmifare.pcdbeep(38);
            tv.setText(Integer.toHexString(FileIndex+1)+" 号文件创建成功！");
        } else {
            PrintErrInf(status);   //返回代码提示
        }
    }

    public void cpu_rsfileadd(View view){
        byte status;                         //存放返回值
        byte RKLen = 16 ;                    //文件 只读权限密码 长度
        byte[] RFilekey = new byte[RKLen];   //文件 只读权限密码
        byte WKLen = 16 ;                    //文件 读写权限密码 长度
        byte[] WFilekey = new byte[WKLen];   //文件 读写权限密码，此权限高，可认证此密码修改只读密码，要记住文件密码

        Spinner spls = findViewById(R.id.spin_SelCreatefilenum);
        byte FileIndex = (byte)(spls.getSelectedItemId());   //指定文件号

        EditText ctrfilesize = findViewById(R.id.textfileszie);  //文件大小
        int FileSize=Integer.parseInt(ctrfilesize.getText().toString().trim());

        EditText ctrreadkey=findViewById(R.id.readkey) ;
        String readkeystr=ctrreadkey.getText().toString().trim();
        if (readkeystr.length() < 32)
        {
            tv.setText("文件只读密钥是32位16进制数据，请输入正确的只读密钥!");
            return;
        }else {
            for (int i = 0; i < 16; i++) {
                RFilekey[i] = (byte) Integer.parseInt(readkeystr.substring(i * 2, i * 2 + 2), 16);//只有用Integer.parseInt才能杜绝大于128时的错误
            }
        }

        EditText ctrwritekey=findViewById(R.id.writekey) ;
        String writekeystr=ctrwritekey.getText().toString().trim();
        if (writekeystr.length() < 32)
        {
            tv.setText("文件读写密钥是32位16进制数据，请输入正确的读写密钥!");
            return;
        }else {
            for (int i = 0; i < 16; i++) {
                WFilekey[i] = (byte) Integer.parseInt(writekeystr.substring(i * 2, i * 2 + 2), 16);//只有用Integer.parseInt才能杜绝大于128时的错误
            }
        }

        status =ourmifare.cpursfileadd(FileIndex, RFilekey, RKLen, WFilekey, WKLen, FileSize) ;  //
        if (status == 0 ) {
            ourmifare.pcdbeep(38);
            tv.setText(Integer.toHexString(FileIndex+1)+" 号文件创建成功！");
        } else {
            PrintErrInf(status);   //返回代码提示
        }
    }

    public void cpu_rsfilekeychg(View view){
        byte status;                         //存放返回值
        byte OldKey;
        byte AKLen = 16 ;                    //文件 认证密码 长度
        byte[] Autkey = new byte[AKLen];     //文件 认证密码
        byte NKLen = 16 ;                    //文件 新密码密码 长度
        byte[] Newkey = new byte[NKLen];     //文件 新密码密码

        Spinner spls = findViewById(R.id.spin_Selchangkeyfile);
        byte FileIndex = (byte)(spls.getSelectedItemId());   //指定文件号

        Spinner spcharw = findViewById(R.id.spin_SelchangRWkey);
        byte ChaKey= (byte)(spcharw.getSelectedItemId());       //取值 0 表示用只读密码来认证，取值 2 表示用读写密码来认证

        Spinner spsuthkey = findViewById(R.id.spin_Selauthkey);
        if (spsuthkey.getSelectedItemId()==0) {
            OldKey = 0;               //取值 0 表示用只读密码来认证，取值 2 表示用读写密码来认证
        }else {OldKey=2;}

        byte ctrlCode=(byte)(ChaKey+OldKey);

        EditText ctrauthkey=findViewById(R.id.authkey0) ;
        String authkeystr=ctrauthkey.getText().toString().trim();
        if (authkeystr.length() < 32)
        {
             tv.setText("文件认证密钥是32位16进制数据，请输入正确的认证密钥!");
             return;
        }else {
            for (int i = 0; i < 16; i++) {
                Autkey[i] = (byte) Integer.parseInt(authkeystr.substring(i * 2, i * 2 + 2), 16);//只有用Integer.parseInt才能杜绝大于128时的错误
            }
        }

        EditText ctrnewkey=findViewById(R.id.newkey) ;
        String newkeystr=ctrnewkey.getText().toString().trim();
        if (newkeystr.length() < 32)
        {
            tv.setText("文件新密钥是32位16进制数据，请输入正确的新密钥!");
            return;
        }else {
            for (int i = 0; i < 16; i++) {
                Newkey[i] = (byte) Integer.parseInt(newkeystr.substring(i * 2, i * 2 + 2), 16);//只有用Integer.parseInt才能杜绝大于128时的错误
            }
        }

        status =ourmifare.cpursfilekeychg(FileIndex, ctrlCode, Autkey, AKLen, Newkey, NKLen) ;//& 0xff用于转为无符号行数据
        if (status == 0 ) {
            ourmifare.pcdbeep(38);
            tv.setText(Integer.toHexString(FileIndex+1)+" 号文件密码修改成功！" );
        } else {
            PrintErrInf(status);   //返回代码提示
        }
    }

    public void cpu_readfile(View view){
        byte status;                          //存放返回值
        byte AKLen = 16 ;                     //文件 认证密码 长度
        byte[] Autkey = new byte[AKLen];      //文件 认证密码
        byte DataStart=0;                     //读起始位置
        byte DataLen = 0 ;                   //读长度最大不能超过255，如文件长度>255 要循环读取
        byte[] DataBuf = new byte[300];      //读文件数据缓冲
        byte ctrlCode=0;                     //取值 0 表示用只读密码来认证，取值 2 表示用读写密码来认证

        EditText ctrrwdata = findViewById(R.id.editrwdata);
        ctrrwdata.setText("");

        Spinner spls = findViewById(R.id.spin_SelRWfile);
        byte FileIndex = (byte)(spls.getSelectedItemId());   //指定文件号

        Spinner spsuthkey = findViewById(R.id.spin_SelRWauthkey);
        if (spsuthkey.getSelectedItemId()==0) {
            ctrlCode = 0;               //取值 0 表示用只读密码来认证，取值 2 表示用读写密码来认证
        }else {ctrlCode=2;}

        EditText ctrauthkey=findViewById(R.id.editrwauthkey) ;
        String authkeystr=ctrauthkey.getText().toString().trim();
        if (authkeystr.length() < 32)
        {
            tv.setText("文件认证密钥是32位16进制数据，请输入正确的认证密钥!");
            return;
        }else {
            for (int i = 0; i < 16; i++) {
                Autkey[i] = (byte) Integer.parseInt(authkeystr.substring(i * 2, i * 2 + 2), 16);//只有用Integer.parseInt才能杜绝大于128时的错误
            }
        }

        EditText ctrbeginadd = findViewById(R.id.textrwbeginadd);  //操作起始地址
        DataStart=(byte)Integer.parseInt(ctrbeginadd.getText().toString().trim());

        EditText ctrrwlen = findViewById(R.id.textrwlen);          //读写长度
        DataLen=(byte)Integer.parseInt(ctrrwlen.getText().toString().trim());

        if (DataLen<1 || DataLen>255){
            tv.setText("一次读取的数据长度应大于0，小于256！如要读取更多的数据请使用循环的方式读取。");
            return;
        }

        status = ourmifare.cpursfiledataread(FileIndex, ctrlCode, Autkey, AKLen, DataStart, DataBuf,DataLen) ;//& 0xff用于转为无符号行数据
        if (status == 0 ) {
            ourmifare.pcdbeep(38);
            String filedata="";
            for (int i = 0; i < DataLen; i++) {
                String bytestr = "00" + Integer.toHexString(DataBuf[i] & 0xff);
                filedata = filedata + bytestr.substring(bytestr.length() - 2, bytestr.length()) +" ";
            }

            ctrrwdata.setText(filedata);
        } else {
            PrintErrInf(status);   //返回代码提示
        }
    }

    public void cpu_writeeasyfile(View view){
        byte status;                          //存放返回值
        byte AKLen = 16 ;                    //文件 认证密码 长度
        byte[] Autkey = new byte[AKLen];     //文件 认证密码
        byte DataStart=0;                    //写起始位置
        byte DataLen  ;                      //写长度最大不能超过247，如文件长度>247 要循环写入
        byte[] DataBuf = new byte[300];      //写文件数据缓冲
        byte ctrlCode=0;                     //取值 0 表示用只读密码来认证，取值 2 表示用读写密码来认证

        Spinner spls = findViewById(R.id.spin_SelRWfile);
        byte FileIndex = (byte)(spls.getSelectedItemId());   //指定文件号

        Spinner spsuthkey = findViewById(R.id.spin_SelRWauthkey);
        if (spsuthkey.getSelectedItemId()==0) {
            ctrlCode = 0;               //取值 0 表示用只读密码来认证，取值 2 表示用读写密码来认证
        }else {ctrlCode=2;}

        EditText ctrauthkey=findViewById(R.id.editrwauthkey) ;
        String authkeystr=ctrauthkey.getText().toString().trim();
        if (authkeystr.length() < 32)
        {
            tv.setText("文件认证密钥是32位16进制数据，请输入正确的认证密钥!");
            return;
        }else {
            for (int i = 0; i < 16; i++) {
                Autkey[i] = (byte) Integer.parseInt(authkeystr.substring(i * 2, i * 2 + 2), 16);//只有用Integer.parseInt才能杜绝大于128时的错误
            }
        }

        EditText ctrbeginadd = findViewById(R.id.textrwbeginadd);  //操作起始地址
        DataStart=(byte)Integer.parseInt(ctrbeginadd.getText().toString().trim());

        EditText ctrrwlen = findViewById(R.id.textrwlen);          //读写长度
        DataLen=(byte)Integer.parseInt(ctrrwlen.getText().toString().trim());

        if (DataLen<1 || DataLen>247){
            tv.setText("一次写入的数据长度应大于0，小于248，如要写入更多的数据可使用循环的方式写入。");
            return;
        }

        EditText ctrrwdata = findViewById(R.id.editrwdata);        //读写数据
        String rwdatahex=ctrrwdata.getText().toString().trim();
        String[] strArr = rwdatahex.split("\\ ");    /*分割接收到的数据后再分析、处理、返回指令 */
        if (strArr.length247 要循环写入
        byte[] DataBuf = new byte[300];      //写文件数据缓冲
        byte ctrlCode=0;                     //取值 0 表示用只读密码来认证，取值 2 表示用读写密码来认证

        Spinner spls = findViewById(R.id.spin_SelRWfile);
        byte FileIndex = (byte)(spls.getSelectedItemId());   //指定文件号

        Spinner spsuthkey = findViewById(R.id.spin_SelRWauthkey);
        if (spsuthkey.getSelectedItemId()==0) {
            ctrlCode = 0;               //取值 0 表示用只读密码来认证，取值 2 表示用读写密码来认证
        }else {ctrlCode=2;}

        EditText ctrauthkey=findViewById(R.id.editrwauthkey) ;
        String authkeystr=ctrauthkey.getText().toString().trim();
        if (authkeystr.length() < 32)
        {
            tv.setText("文件认证密钥是32位16进制数据，请输入正确的认证密钥!");
            return;
        }else {
            for (int i = 0; i < 16; i++) {
                Autkey[i] = (byte) Integer.parseInt(authkeystr.substring(i * 2, i * 2 + 2), 16);//只有用Integer.parseInt才能杜绝大于128时的错误
            }
        }

        EditText ctrbeginadd = findViewById(R.id.textrwbeginadd);  //操作起始地址
        DataStart=(byte)Integer.parseInt(ctrbeginadd.getText().toString().trim());

        EditText ctrrwlen = findViewById(R.id.textrwlen);          //读写长度
        DataLen=(byte)Integer.parseInt(ctrrwlen.getText().toString().trim());

        if (DataLen<1 || DataLen>247){
            tv.setText("一次写入的数据长度应大于0，小于248，如要写入更多的数据可使用循环的方式写入。");
            return;
        }

        EditText ctrrwdata = findViewById(R.id.editrwdata);        //读写数据
        String rwdatahex=ctrrwdata.getText().toString().trim();
        String[] strArr = rwdatahex.split("\\ ");    /*分割接收到的数据后再分析、处理、返回指令 */
        if (strArr.length