cocos2dx工程中接入支付宝sdk

[摘要]本文是对cocos2dx工程中接入支付宝sdk的讲解，对学习Android编程技术有所帮助,与大家分享。

1. 首先去支付宝官网下载开发者文档

2. 然后按着开发者文档将支付宝的sdk导入到你的工程中，并关联到工程中，步骤入下图：

（1）将从支付宝官方网站获得的支付宝的sdk的jar包拷贝到工程中的libs目录下，如图

（2）右键工程选择Properties，弹出如下窗口，首先选择1，其次选中2，最后点击3将拷到工程中的三个支付宝的jar包一一关联到工程中

3. 最后修改工程的AndroidManifest.xml文件，添加新的权限和支付宝的Activity，代码如下：

新权限：

1

2

3

4

5

6

<uses-permission android:name="android.permission.INTERNET"/>

<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE"/>

<uses-permission android:name="android.permission.ACCESS_WIFI_STATE"/>

<uses-permission android:name="android.permission.READ_PHONE_STATE"/>

<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>

<uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION"/>

支付宝的Activity：

1

2

3

4

5

6

7

8

9

<!-- alipay sdk begin -->

        <activity

            android:name="com.alipay.sdk.app.H5PayActivity"

            android:configChanges="orientation|keyboardHidden|navigation"

            android:exported="false"

            android:screenOrientation="behind"

            android:windowSoftInputMode="adjustResize|stateHidden">

        </activity>

<!-- alipay sdk end -->

到此为止支付宝sdk导入工程的工作算是完成了，接下来就是使用sdk完成付费了。

虽然破坏了java的封装性，但是为了方便起见我还是将支付宝的使用写到了一个java文件里了，我把使用放到了工程自带的HelloCpp.java文件中了，代码如/****************************************************************************Copyright (c) 2010-2012 cocos2d-x.orghttp://www.cocos2d-x.org

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

295

296

297

298

299

300

301

302

303

Permission is hereby granted, free of charge, to any person obtaining a copy

ofthissoftware and associated documentation files (the "Software"), to deal

in the Software without restriction, including without limitation the rights

to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

copies of the Software, and to permit persons to whom the Software is

furnished to doso, subject to the following conditions:

 

The above copyright notice and thispermission notice shall be included in

all copies or substantial portions of the Software.

 

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN

THE SOFTWARE.

****************************************************************************/

packageorg.cocos2dx.hellocpp2;

 

importjava.io.UnsupportedEncodingException;

importjava.net.URLEncoder;

importjava.text.SimpleDateFormat;

importjava.util.Date;

importjava.util.Locale;

importjava.util.Random;

 

importorg.cocos2dx.lib.Cocos2dxActivity;

 

importandroid.os.Bundle;

importandroid.os.Handler;

importandroid.os.Message;

importandroid.text.TextUtils;

importandroid.util.Log;

importandroid.view.View;

importandroid.widget.Toast;

 

importcom.alipay.sdk.app.PayTask;

 

publicclass HelloCpp extendsCocos2dxActivity{

     

    //private long exitTime = 0;

     

    // 私有的类对象

    privatestatic HelloCpp hiCpp = null;

     

    // 传回支付结果

    publicstatic native void payResultState(intpayState);

    <br>　　// 以下参数根据自己的实际情况而定

        //商户PID

        publicstatic final String PARTNER = "2088811977704990";

       //商户收款账号

        publicstatic final String SELLER = "[e-mail]";

        //商户私钥，pkcs8格式

        publicstatic final String RSA_PRIVATE =

                "MIICXQIBAAKBgQDlQ468L1A7Q+GG80/Z8f3IsSiiFIluSxfTTSuJ/XSPzvYS+bMZ"

               +"AQLMqq/nGhkp+1Q5pHF9LAQtQS3gL2pqzbKdtvZSsy/tNFFQcGCsgK2ygMl+MW/F"

               +"g/ufx7c1jy1kZAeDyl1m302dnRrtSgDalkgH7FKRcmDxbXPTnFGHbg9zMQIDAQAB"

               +"AoGAa28wGQF28H7L1Yh5V+FtkrlqGCHVkQjBfnRAPea205kheRzoD4SIwk4OJhb1"

               +"ydWLz4M+53BT+Lz9eXveu3PvCdQe9zMIVC5dKUNVYCvvcHZ+Ot8HriiuwGPb3Quu"

               +"twbnLGM5gxxPDo0yUyWrfaVn/qR35mS6TDfmgowVG8CmBpECQQDzuhodR/Jgxrtn"

               +"tka+88alyy+BfjUZqNloPuE7JfXrpOxH5lodk7Y4lTki/dlo5BrK+hrismLFr9Du"

               +"ueAJ7G9dAkEA8M8C6VnpUMAK5+rYcjKnQssDqcMfurKYEil1BD/TUdSbLI6v8p02"

               +"mv1ApuTVtQQypZJKIFfurGk0g0QlvzLZ5QJAGfY38+iHDAH/UnPbI1oKTfzPyaZs"

               +"95fB2NXh3hAUGw7NUHdcIAxs+6gBlxWdRAwQQpDTrlQ8KzyoL9XC5Ku3zQJBALO8"

               +"j5vEtFTFQl6f9zYlgJpmFTHcpg4fx0mnD+RAD2aAneHADquzlFJSvLLVEn2tyG+0"

               +"pQdHGqotTDi94L65IdECQQDb1h+5kugCu47IxsDkrLRsKVcr8dSDMORyeT1L0HWR"

               +"ctramBu+2PBz2UKC6+9dQ+ZQH4XTKpBSvkyZH4mYi1de";

        //支付宝公钥

        publicstatic final String RSA_PUBLIC = "MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCnxj/9qwVfgoUh/y2W89L6BkRAFljhNhgPdyPuBV64bfQNN1PjbCzkIM6qRdKBoLPXmKKMiFYnkd6rAoprih3/PrQEB/VsW8OoM8fxn67UDYuyBTqA23MML9q1+ilIZwBC2AQ2UBVOrFXfFl75p6/B5KsiNG9zpgmLCUYuLkxpLQIDAQAB";

 

    privatestatic final int SDK_PAY_FLAG = 1;

 

    privatestatic final int SDK_CHECK_FLAG = 2;

 

    // 支付结果的处理(接收子线程反馈回来的消息)

    privateHandler mHandler = newHandler() {

         

        publicvoid handleMessage(Message msg) {

            switch(msg.what) {

                caseSDK_PAY_FLAG: {

                    PayResult payResult = newPayResult((String) msg.obj);

                     

                    // 支付宝返回此次支付结果及加签，建议对支付宝签名信息拿签约时支付宝提供的公钥做验签

                    String resultInfo = payResult.getResult();

                     

                    String resultStatus = payResult.getResultStatus();

 

                    // 判断resultStatus 为“9000”则代表支付成功，具体状态码代表含义可参考接口文档

                    if(TextUtils.equals(resultStatus, "9000")) {

                        //Toast.makeText(HelloCpp.this, "支付成功", Toast.LENGTH_SHORT).show();

                        HelloCpp.payResultState(1);

                    }else{

                        // 判断resultStatus 为非“9000”则代表可能支付失败

                        // “8000”代表支付结果因为支付渠道原因或者系统原因还在等待支付结果确认，最终交易是否成功以服务端异步通知为准（小概率状态）

                        if(TextUtils.equals(resultStatus, "8000")) {

                        //    Toast.makeText(HelloCpp.this, "支付结果确认中", Toast.LENGTH_SHORT).show();

                            HelloCpp.payResultState(3);

                        }else{

                            // 其他值就可以判断为支付失败，包括用户主动取消支付，或者系统返回的错误

                        //    Toast.makeText(HelloCpp.this, "支付失败", Toast.LENGTH_SHORT).show();

                            HelloCpp.payResultState(2);

                        }

                    }

                    break;

                }

                caseSDK_CHECK_FLAG: {

                    Toast.makeText(HelloCpp.this,"检查结果为："+ msg.obj,

                            Toast.LENGTH_SHORT).show();

                    break;

                }

                default:

                    break;

                }

            };

     

    };

         

        protectedvoid onCreate(Bundle savedInstanceState){

            super.onCreate(savedInstanceState);

            hiCpp = this;

        }

         

        publicstatic Object rtnActivity() {

            System.out.println("----------rtnActivity");

            returnhiCpp ;

        }

         

        static{

            System.loadLibrary("hellocpp");

        }  

 

        /**

         * call alipay sdk pay. 调用SDK支付

         *

         */

        publicvoid pay(String title, String content, floatf) {

         

            String price = Float.toString( f );

            // 订单

            String orderInfo = getOrderInfo( title, content, price );

 

            // 对订单做 RSA 签名

            String sign = sign(orderInfo);

            try{

                // 仅需对sign 做URL编码

                sign = URLEncoder.encode(sign, "UTF-8");

            }catch(UnsupportedEncodingException e) {

                e.printStackTrace();

            }

 

            // 完整的符合支付宝参数规范的订单信息

            finalString payInfo = orderInfo + "&sign=\""+ sign + "\"&"

                    + getSignType();

 

            Runnable payRunnable = newRunnable() {

 

                @Override

                publicvoid run() {

                    // 构造PayTask 对象

                    PayTask alipay = newPayTask(HelloCpp.this);

                    // 调用支付接口，获取支付结果

                    String result = alipay.pay(payInfo);

 

                    Message msg = newMessage();

                    msg.what = SDK_PAY_FLAG;

                    msg.obj = result;

                    mHandler.sendMessage(msg);

                }

            };

 

            // 必须异步调用

            Thread payThread = newThread(payRunnable);

            payThread.start();

        }

 

        /**

         * check whether the device has authentication alipay account.

         * 查询终端设备是否存在支付宝认证账户

         *

         */

        publicvoid check(View v) {

            Runnable checkRunnable = newRunnable() {

 

                @Override

                publicvoid run() {

                    // 构造PayTask 对象

                    PayTask payTask = newPayTask(HelloCpp.this);

                    // 调用查询接口，获取查询结果

                    booleanisExist = payTask.checkAccountIfExist();

 

                    Message msg = newMessage();

                    msg.what = SDK_CHECK_FLAG;

                    msg.obj = isExist;

                    mHandler.sendMessage(msg);

                }

            };

 

            Thread checkThread = newThread(checkRunnable);

            checkThread.start();

 

        }

 

        /**

         * get the sdk version. 获取SDK版本号

         *

         */

        publicvoid getSDKVersion() {

            PayTask payTask = newPayTask(this);

            String version = payTask.getVersion();

            Toast.makeText(this, version, Toast.LENGTH_SHORT).show();

        }

 

        /**

         * create the order info. 创建订单信息

         *

         */

        publicString getOrderInfo(String subject, String body, String price) {

            // 签约合作者身份ID

            String orderInfo = "partner="+ "\""+ PARTNER + "\"";

 

            // 签约卖家支付宝账号

            orderInfo += "&seller_id="+ "\""+ SELLER + "\"";

 

            // 商户网站唯一订单号

            orderInfo += "&out_trade_no="+ "\""+ getOutTradeNo() + "\"";

 

            // 商品名称

            orderInfo += "&subject="+ "\""+ subject + "\"";

 

            // 商品详情

            orderInfo += "&body="+ "\""+ body + "\"";

 

            // 商品金额

            orderInfo += "&total_fee="+ "\""+ price + "\"";

 

            // 服务器异步通知页面路径

            orderInfo += "&notify_url="+ "\""+ "http://notify.msp.hk/notify.htm"

                    +"\"";

 

            // 服务接口名称， 固定值

            orderInfo += "&service=\"mobile.securitypay.pay\"";

 

            // 支付类型， 固定值

            orderInfo += "&payment_type=\"1\"";

 

            // 参数编码， 固定值

            orderInfo += "&_input_charset=\"utf-8\"";

 

            // 设置未付款交易的超时时间

            // 默认30分钟，一旦超时，该笔交易就会自动被关闭。

            // 取值范围：1m～15d。

            // m-分钟，h-小时，d-天，1c-当天（无论交易何时创建，都在0点关闭）。

            // 该参数数值不接受小数点，如1.5h，可转换为90m。

            orderInfo += "&it_b_pay=\"30m\"";

 

            // extern_token为经过快登授权获取到的alipay_open_id,带上此参数用户将使用授权的账户进行支付

            // orderInfo += "&extern_token=" + "\"" + extern_token + "\"";

 

            // 支付宝处理完请求后，当前页面跳转到商户指定页面的路径，可空

            orderInfo += "&return_url=\"m.alipay.com\"";

 

            // 调用银行卡支付，需配置此参数，参与签名， 固定值 （需要签约《无线银行卡快捷支付》才能使用）

            // orderInfo += "&paymethod=\"expressGateway\"";

 

            returnorderInfo;

        }

 

        /**

         * get the out_trade_no for an order. 生成商户订单号，该值在商户端应保持唯一（可自定义格式规范）

         *

         */

        publicString getOutTradeNo() {

            SimpleDateFormat format = newSimpleDateFormat("MMddHHmmss",

                    Locale.getDefault());

            Date date = newDate();

            String key = format.format(date);

 

            Random r = newRandom();

            key = key + r.nextInt();

            key = key.substring(0,15);

            returnkey;

        }

 

        /**

         * sign the order info. 对订单信息进行签名

         *

         * @param content

         *            待签名订单信息

         */

        publicString sign(String content) {

            returnSignUtils.sign(content, RSA_PRIVATE);

        }

 

        /**

         * get the sign type we use. 获取签名方式

         *

         */

        publicString getSignType() {

            return"sign_type=\"RSA\"";

        }

     

}

还有支付宝封装好的几个java文件，我把它们跟HelloCpp.java文件放到了同一个包中，它们分别是Base64.java，PayResult.java，SignUtils.java，源码如下：

（1）Base64.java文件源码

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

packageorg.cocos2dx.hellocpp2;

 

publicfinal class Base64 {

 

    privatestatic final int BASELENGTH = 128;

    privatestatic final int LOOKUPLENGTH = 64;

    privatestatic final int TWENTYFOURBITGROUP = 24;

    privatestatic final int EIGHTBIT = 8;

    privatestatic final int SIXTEENBIT = 16;

    privatestatic final int FOURBYTE = 4;

    privatestatic final int SIGN = -128;

    privatestatic char PAD = '=';

    privatestatic byte[] base64Alphabet = newbyte[BASELENGTH];

    privatestatic char[] lookUpBase64Alphabet = newchar[LOOKUPLENGTH];

 

    static{

        for(inti = 0; i < BASELENGTH; ++i) {

            base64Alphabet[i] = -1;

        }

        for(inti = 'Z'; i >= 'A'; i--) {

            base64Alphabet[i] = (byte) (i - 'A');

        }

        for(inti = 'z'; i >= 'a'; i--) {

            base64Alphabet[i] = (byte) (i - 'a'+ 26);

        }

 

        for(inti = '9'; i >= '0'; i--) {

            base64Alphabet[i] = (byte) (i - '0'+ 52);

        }

 

        base64Alphabet['+'] = 62;

        base64Alphabet['/'] = 63;

 

        for(inti = 0; i <= 25; i++) {

            lookUpBase64Alphabet[i] = (char) ('A'+ i);

        }

 

        for(inti = 26, j = 0; i <= 51; i++, j++) {

            lookUpBase64Alphabet[i] = (char) ('a'+ j);

        }

 

        for(inti = 52, j = 0; i <= 61; i++, j++) {

            lookUpBase64Alphabet[i] = (char) ('0'+ j);

        }

        lookUpBase64Alphabet[62] = (char)'+';

        lookUpBase64Alphabet[63] = (char)'/';

 

    }

 

    privatestatic boolean isWhiteSpace(charoctect) {

        return(octect == 0x20|| octect == 0xd|| octect == 0xa|| octect == 0x9);

    }

 

    privatestatic boolean isPad(charoctect) {

        return(octect == PAD);

    }

 

    privatestatic boolean isData(charoctect) {

        return(octect < BASELENGTH && base64Alphabet[octect] != -1);

    }

 

    /**

     * Encodes hex octects into Base64

     *

     * @param binaryData

     *            Array containing binaryData

     * @return Encoded Base64 array

     */

    publicstatic String encode(byte[] binaryData) {

 

        if(binaryData == null) {

            returnnull;

        }

 

        intlengthDataBits = binaryData.length * EIGHTBIT;

        if(lengthDataBits == 0) {

            return"";

        }

 

        intfewerThan24bits = lengthDataBits % TWENTYFOURBITGROUP;

        intnumberTriplets = lengthDataBits / TWENTYFOURBITGROUP;

        intnumberQuartet = fewerThan24bits != 0? numberTriplets + 1

                : numberTriplets;

        charencodedData[] = null;

 

        encodedData = newchar[numberQuartet * 4];

 

        bytek = 0, l = 0, b1 = 0, b2 = 0, b3 = 0;

 

        intencodedIndex = 0;

        intdataIndex = 0;

 

        for(inti = 0; i < numberTriplets; i++) {

            b1 = binaryData[dataIndex++];

            b2 = binaryData[dataIndex++];

            b3 = binaryData[dataIndex++];

 

            l = (byte) (b2 & 0x0f);

            k = (byte) (b1 & 0x03);

 

            byteval1 = ((b1 & SIGN) == 0) ? (byte) (b1 >> 2)

                    : (byte) ((b1) >> 2^ 0xc0);

            byteval2 = ((b2 & SIGN) == 0) ? (byte) (b2 >> 4)

                    : (byte) ((b2) >> 4^ 0xf0);

            byteval3 = ((b3 & SIGN) == 0) ? (byte) (b3 >> 6)

                    : (byte) ((b3) >> 6^ 0xfc);

 

            encodedData[encodedIndex++] = lookUpBase64Alphabet[val1];

            encodedData[encodedIndex++] = lookUpBase64Alphabet[val2 | (k << 4)];

            encodedData[encodedIndex++] = lookUpBase64Alphabet[(l << 2) | val3];

            encodedData[encodedIndex++] = lookUpBase64Alphabet[b3 & 0x3f];

        }

 

        // form integral number of 6-bit groups

        if(fewerThan24bits == EIGHTBIT) {

            b1 = binaryData[dataIndex];

            k = (byte) (b1 & 0x03);

             

            byteval1 = ((b1 & SIGN) == 0) ? (byte) (b1 >> 2)

                    : (byte) ((b1) >> 2^ 0xc0);

            encodedData[encodedIndex++] = lookUpBase64Alphabet[val1];

            encodedData[encodedIndex++] = lookUpBase64Alphabet[k << 4];

            encodedData[encodedIndex++] = PAD;

            encodedData[encodedIndex++] = PAD;

        }elseif (fewerThan24bits == SIXTEENBIT) {

            b1 = binaryData[dataIndex];

            b2 = binaryData[dataIndex + 1];

            l = (byte) (b2 & 0x0f);

            k = (byte) (b1 & 0x03);

 

            byteval1 = ((b1 & SIGN) == 0) ? (byte) (b1 >> 2)

                    : (byte) ((b1) >> 2^ 0xc0);

            byteval2 = ((b2 & SIGN) == 0) ? (byte) (b2 >> 4)

                    : (byte) ((b2) >> 4^ 0xf0);

 

            encodedData[encodedIndex++] = lookUpBase64Alphabet[val1];

            encodedData[encodedIndex++] = lookUpBase64Alphabet[val2 | (k << 4)];

            encodedData[encodedIndex++] = lookUpBase64Alphabet[l << 2];

            encodedData[encodedIndex++] = PAD;

        }

 

        returnnew String(encodedData);

    }

 

    /**

     * Decodes Base64 data into octects

     *

     * @param encoded

     *            string containing Base64 data

     * @return Array containind decoded data.

     */

    publicstatic byte[] decode(String encoded) {

 

        if(encoded == null) {

            returnnull;

        }

 

        char[] base64Data = encoded.toCharArray();

        // remove white spaces

        intlen = removeWhiteSpace(base64Data);

 

        if(len % FOURBYTE != 0) {

            returnnull;// should be divisible by four

        }

 

        intnumberQuadruple = (len / FOURBYTE);

 

        if(numberQuadruple == 0) {

            returnnew byte[0];

        }

 

        bytedecodedData[] = null;

        byteb1 = 0, b2 = 0, b3 = 0, b4 = 0;

        chard1 = 0, d2 = 0, d3 = 0, d4 = 0;

 

        inti = 0;

        intencodedIndex = 0;

        intdataIndex = 0;

        decodedData = newbyte[(numberQuadruple) * 3];

 

        for(; i < numberQuadruple - 1; i++) {

 

            if(!isData((d1 = base64Data[dataIndex++]))

                    || !isData((d2 = base64Data[dataIndex++]))

                    || !isData((d3 = base64Data[dataIndex++]))

                    || !isData((d4 = base64Data[dataIndex++]))) {

                returnnull;

            }// if found "no data" just return null

 

            b1 = base64Alphabet[d1];

            b2 = base64Alphabet[d2];

            b3 = base64Alphabet[d3];

            b4 = base64Alphabet[d4];

 

            decodedData[encodedIndex++] = (byte) (b1 << 2| b2 >> 4);

            decodedData[encodedIndex++] = (byte) (((b2 & 0xf) << 4) | ((b3 >> 2) & 0xf));

            decodedData[encodedIndex++] = (byte) (b3 << 6| b4);

        }

 

        if(!isData((d1 = base64Data[dataIndex++]))

                || !isData((d2 = base64Data[dataIndex++]))) {

            returnnull;// if found "no data" just return null

        }

 

        b1 = base64Alphabet[d1];

        b2 = base64Alphabet[d2];

 

        d3 = base64Data[dataIndex++];

        d4 = base64Data[dataIndex++];

        if(!isData((d3)) || !isData((d4))) {// Check if they are PAD characters

            if(isPad(d3) && isPad(d4)) {

                if((b2 & 0xf) != 0)// last 4 bits should be zero

                {

                    returnnull;

                }

                byte[] tmp = newbyte[i * 3+ 1];

                System.arraycopy(decodedData,0, tmp, 0, i * 3);

                tmp[encodedIndex] = (byte) (b1 << 2| b2 >> 4);

                returntmp;

            }elseif (!isPad(d3) && isPad(d4)) {

                b3 = base64Alphabet[d3];

                if((b3 & 0x3) != 0)// last 2 bits should be zero

                {

                    returnnull;

                }

                byte[] tmp = newbyte[i * 3+ 2];

                System.arraycopy(decodedData,0, tmp, 0, i * 3);

                tmp[encodedIndex++] = (byte) (b1 << 2| b2 >> 4);

                tmp[encodedIndex] = (byte) (((b2 & 0xf) << 4) | ((b3 >> 2) & 0xf));

                returntmp;

            }else{

                returnnull;

            }

        }else{ // No PAD e.g 3cQl

            b3 = base64Alphabet[d3];

            b4 = base64Alphabet[d4];

            decodedData[encodedIndex++] = (byte) (b1 << 2| b2 >> 4);

            decodedData[encodedIndex++] = (byte) (((b2 & 0xf) << 4) | ((b3 >> 2) & 0xf));

            decodedData[encodedIndex++] = (byte) (b3 << 6| b4);

 

        }

 

        returndecodedData;

    }

 

    /**

     * remove WhiteSpace from MIME containing encoded Base64 data.

     *

     * @param data

     *            the byte array of base64 data (with WS)

     * @return the new length

     */

    privatestatic int removeWhiteSpace(char[] data) {

        if(data == null) {

            return0;

        }

 

        // count characters that's not whitespace

        intnewSize = 0;

        intlen = data.length;

        for(inti = 0; i < len; i++) {

            if(!isWhiteSpace(data[i])) {

                data[newSize++] = data[i];

            }

        }

        returnnewSize;

    }

}

（2）PayResult.java文件源码

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

packageorg.cocos2dx.hellocpp2;

 

importandroid.text.TextUtils;

 

publicclass PayResult {

    privateString resultStatus;

    privateString result;

    privateString memo;

 

    publicPayResult(String rawResult) {

 

        if(TextUtils.isEmpty(rawResult))

            return;

 

        String[] resultParams = rawResult.split(";");

        for(String resultParam : resultParams) {

            if(resultParam.startsWith("resultStatus")) {

                resultStatus = gatValue(resultParam, "resultStatus");

            }

            if(resultParam.startsWith("result")) {

                result = gatValue(resultParam, "result");

            }

            if(resultParam.startsWith("memo")) {

                memo = gatValue(resultParam, "memo");

            }

        }

    }

 

    @Override

    publicString toString() {

        return"resultStatus={" + resultStatus + "};memo={"+ memo

                +"};result={"+ result + "}";

    }

 

    privateString gatValue(String content, String key) {

        String prefix = key + "={";

        returncontent.substring(content.indexOf(prefix) + prefix.length(),

                content.lastIndexOf("}"));

    }

 

    /**

     * @return the resultStatus

     */

    publicString getResultStatus() {

        returnresultStatus;

    }

 

    /**

     * @return the memo

     */

    publicString getMemo() {

        returnmemo;

    }

 

    /**

     * @return the result

     */

    publicString getResult() {

        returnresult;

    }

}

（3）SignUtils.java文件源码

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

packageorg.cocos2dx.hellocpp2;

 

importjava.security.KeyFactory;

importjava.security.PrivateKey;

importjava.security.spec.PKCS8EncodedKeySpec;

 

publicclass SignUtils {

 

    privatestatic final String ALGORITHM = "RSA";

 

    privatestatic final String SIGN_ALGORITHMS = "SHA1WithRSA";

 

    privatestatic final String DEFAULT_CHARSET = "UTF-8";

 

    publicstatic String sign(String content, String privateKey) {

        try{

            PKCS8EncodedKeySpec priPKCS8 = newPKCS8EncodedKeySpec(

                    Base64.decode(privateKey));

            //KeyFactory keyf = KeyFactory.getInstance(ALGORITHM);

            KeyFactory keyf = KeyFactory.getInstance(ALGORITHM, "BC");

            PrivateKey priKey = keyf.generatePrivate(priPKCS8);

 

            java.security.Signature signature = java.security.Signature

                    .getInstance(SIGN_ALGORITHMS);

 

            signature.initSign(priKey);

            signature.update(content.getBytes(DEFAULT_CHARSET));

 

            byte[] signed = signature.sign();

 

            returnBase64.encode(signed);

        }catch(Exception e) {

            e.printStackTrace();

        }

 

        returnnull;

    }

 

}

至此cocos2dx工程中接入支付宝的工作完成！