API tools faq
paste
deadman96385

button_java

deadman96385
Nov 7th, 2017
219
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 24.10 KB | None | 0 0
raw download clone embed print report
  1. /* Copyright Statement:
  2. *
  3. * This software/firmware and related documentation ("MediaTek Software") are
  4. * protected under relevant copyright laws. The information contained herein is
  5. * confidential and proprietary to MediaTek Inc. and/or its licensors. Without
  6. * the prior written permission of MediaTek inc. and/or its licensors, any
  7. * reproduction, modification, use or disclosure of MediaTek Software, and
  8. * information contained herein, in whole or in part, shall be strictly
  9. * prohibited.
  10. *
  11. * MediaTek Inc. (C) 2010. All rights reserved.
  12. *
  13. * BY OPENING THIS FILE, RECEIVER HEREBY UNEQUIVOCALLY ACKNOWLEDGES AND AGREES
  14. * THAT THE SOFTWARE/FIRMWARE AND ITS DOCUMENTATIONS ("MEDIATEK SOFTWARE")
  15. * RECEIVED FROM MEDIATEK AND/OR ITS REPRESENTATIVES ARE PROVIDED TO RECEIVER
  16. * ON AN "AS-IS" BASIS ONLY. MEDIATEK EXPRESSLY DISCLAIMS ANY AND ALL
  17. * WARRANTIES, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED
  18. * WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR
  19. * NONINFRINGEMENT. NEITHER DOES MEDIATEK PROVIDE ANY WARRANTY WHATSOEVER WITH
  20. * RESPECT TO THE SOFTWARE OF ANY THIRD PARTY WHICH MAY BE USED BY,
  21. * INCORPORATED IN, OR SUPPLIED WITH THE MEDIATEK SOFTWARE, AND RECEIVER AGREES
  22. * TO LOOK ONLY TO SUCH THIRD PARTY FOR ANY WARRANTY CLAIM RELATING THERETO.
  23. * RECEIVER EXPRESSLY ACKNOWLEDGES THAT IT IS RECEIVER'S SOLE RESPONSIBILITY TO
  24. * OBTAIN FROM ANY THIRD PARTY ALL PROPER LICENSES CONTAINED IN MEDIATEK
  25. * SOFTWARE. MEDIATEK SHALL ALSO NOT BE RESPONSIBLE FOR ANY MEDIATEK SOFTWARE
  26. * RELEASES MADE TO RECEIVER'S SPECIFICATION OR TO CONFORM TO A PARTICULAR
  27. * STANDARD OR OPEN FORUM. RECEIVER'S SOLE AND EXCLUSIVE REMEDY AND MEDIATEK'S
  28. * ENTIRE AND CUMULATIVE LIABILITY WITH RESPECT TO THE MEDIATEK SOFTWARE
  29. * RELEASED HEREUNDER WILL BE, AT MEDIATEK'S OPTION, TO REVISE OR REPLACE THE
  30. * MEDIATEK SOFTWARE AT ISSUE, OR REFUND ANY SOFTWARE LICENSE FEES OR SERVICE
  31. * CHARGE PAID BY RECEIVER TO MEDIATEK FOR SUCH MEDIATEK SOFTWARE AT ISSUE.
  32. *
  33. * The following software/firmware and/or related documentation ("MediaTek
  34. * Software") have been modified by MediaTek Inc. All revisions are subject to
  35. * any receiver's applicable license agreements with MediaTek Inc.
  36. */
  37.  
  38. package com.mediatek.engineermode.bluetooth;
  39.  
  40. import android.app.Activity;
  41. import android.app.AlertDialog;
  42. import android.app.Dialog;
  43. import android.app.ProgressDialog;
  44. import android.bluetooth.BluetoothAdapter;
  45. import android.content.DialogInterface;
  46. import android.os.Bundle;
  47. import android.os.Handler;
  48. import android.os.HandlerThread;
  49. import android.os.Looper;
  50. import android.os.Message;
  51. import android.view.Menu;
  52. import android.view.MenuInflater;
  53. import android.view.MenuItem;
  54. import android.view.View;
  55. import android.view.View.OnClickListener;
  56. import android.widget.ArrayAdapter;
  57. import android.widget.Button;
  58. import android.widget.Spinner;
  59. import android.widget.TextView;
  60.  
  61. import com.mediatek.engineermode.R;
  62. import com.mediatek.xlog.Xlog;
  63.  
  64. /**
  65. * Do BT tx mode test.
  66. *
  67. * @author mtk54040
  68. *
  69. */
  70. public class TxOnlyTestActivity extends Activity implements
  71. DialogInterface.OnCancelListener {
  72.  
  73. private BluetoothAdapter mAdapter;
  74.  
  75. private Spinner mPattern = null;
  76. private Spinner mChannels = null;
  77. private Spinner mPktTypes = null;
  78.  
  79. private BtTest mBtTest = null;
  80.  
  81. private static final int BT_TEST_0 = 0;
  82. private static final int BT_TEST_3 = 3;
  83. private static final int RETURN_FAIL = -1;
  84.  
  85. // dialog ID and MSG ID
  86. private static final int CHECK_BT_STATE = 1;
  87. // private static final int CHECK_BT_DEVEICE = 2;
  88. private static final int TEST_TX = 3;
  89.  
  90. private static final int DIALOG_BT_STOP = 4;
  91.  
  92.  
  93. private boolean mHasInit = false;
  94. private boolean mIniting = false;
  95. private boolean mNonModulate = false;
  96. private boolean mPocketType = false;
  97.  
  98. private static final int MAP_TO_PATTERN = 0;
  99. private static final int MAP_TO_CHANNELS = 1;
  100. private static final int MAP_TO_POCKET_TYPE = 2;
  101. private static final int MAP_TO_FREQ = 3;
  102. private static final int MAP_TO_POCKET_TYPE_LEN = 4;
  103.  
  104. private static final String TAG = "TxOnlyTestLOG";
  105.  
  106. private int mStateBt;
  107. // added by chaozhong @2010-10-10
  108. private Handler mWorkHandler = null; // used to handle the
  109. private HandlerThread mWorkThread = null;
  110. // "done"
  111. // button clicked action
  112. private boolean mDoneTest = true; // used to record weather the
  113.  
  114. private boolean mDumpStart = false;
  115. // "done" button clicked
  116. // event has been finished
  117. // private HandlerThread mHandlerThread = null;
  118. public static final int DLGID_OP_IN_PROCESS = 1;
  119. public static final int OP_IN_PROCESS = 2;
  120. public static final int OP_FINISH = 0;
  121. public static final int OP_TX_FAIL = 4;
  122.  
  123. public static final int UI_BT_CLOSE = 5;
  124. public static final int UI_BT_CLOSE_FINISHED = 6;
  125.  
  126. private static final int OP_BT_SEND = 11;
  127. private static final int OP_BT_STOP = 12;
  128.  
  129. Button done, revert;
  130.  
  131. // private static Handler mUiHandler = null;
  132. // ProgressDialog mDialogSearchProgress = null;
  133.  
  134. // end added
  135. @Override
  136. public void onCreate(Bundle savedInstanceState) {
  137. // Xlog.v(TAG, "-->onCreate");
  138. super.onCreate(savedInstanceState);
  139. setContentView(R.layout.tx_only_test);
  140. // Initialize the UI component
  141. setValuesSpinner();
  142.  
  143. mWorkThread = new HandlerThread(TAG);
  144. mWorkThread.start();
  145. Looper looper = mWorkThread.getLooper();
  146. mWorkHandler = new WorkHandler(looper);
  147. done = (Button) findViewById(R.id.donebutton);
  148. revert = (Button) findViewById(R.id.revertbutton);
  149.  
  150. done.setOnClickListener(new View.OnClickListener() {
  151. @Override
  152. public void onClick(View view) {
  153. Xlog.i(TAG, "menu_done is clicked.");
  154. if (mDoneTest) {
  155. // if the last click action has been handled, send another event request
  156. mWorkHandler.sendEmptyMessage(OP_BT_SEND);
  157. } else {
  158. Xlog.i(TAG, "last click is not finished yet.");
  159. }
  160. }
  161. });
  162.  
  163. revert.setOnClickListener(new View.OnClickListener() {
  164. @Override
  165. public void onClick(View view) {
  166. doRevertAction();
  167. }
  168. });
  169. }
  170. }
  171.  
  172. private Handler mUiHandler = new Handler() {
  173. public void handleMessage(Message msg) {
  174. switch (msg.what) {
  175. case OP_IN_PROCESS:
  176. // {
  177. Xlog.w(TAG, "OP_IN_PROCESS");
  178. showDialog(TEST_TX);
  179. break;
  180. case OP_FINISH:
  181. Xlog.i(TAG, "OP_FINISH");
  182. removeDialog(TEST_TX);
  183. break;
  184. case OP_TX_FAIL:
  185. Xlog.i(TAG, "OP_TX_FAIL");
  186. // showDialog(DIALOG_CHECK_BT_DEVEICE);
  187. removeDialog(TEST_TX);
  188. break;
  189. case UI_BT_CLOSE:
  190. Xlog.i(TAG, "UI_BT_CLOSE");
  191. showDialog(DIALOG_BT_STOP);
  192. break;
  193. case UI_BT_CLOSE_FINISHED:
  194. Xlog.i(TAG, "UI_BT_CLOSE_FINISHED");
  195. removeDialog(DIALOG_BT_STOP);
  196. finish();
  197. break;
  198. default:
  199. break;
  200. }
  201. }
  202. };
  203. private final class WorkHandler extends Handler {
  204. private WorkHandler(Looper looper) {
  205. super(looper);
  206. }
  207.  
  208. @Override
  209. public void handleMessage(Message msg) {
  210. if (msg.what == OP_BT_SEND) {
  211. mUiHandler.sendEmptyMessage(OP_IN_PROCESS);
  212. mDoneTest = false;
  213. // do stop
  214. if (mDumpStart == true) {
  215. if (mBtTest != null) {
  216. Xlog.i(TAG, "pollingStop");
  217. mBtTest.pollingStop();
  218. if (RETURN_FAIL == mBtTest.doBtTest(BT_TEST_3)) { // bt deinit
  219. Xlog.i(TAG, "stop failed.");
  220. }
  221. }
  222. }
  223. doSendCommandAction();
  224. // do start
  225. if (mBtTest != null && mHasInit) {
  226. Xlog.i(TAG, "pollingStart");
  227. mBtTest.pollingStart();
  228. mDumpStart = true;
  229. }
  230. mDoneTest = true;
  231. mUiHandler.sendEmptyMessage(OP_FINISH);
  232. } else if (msg.what == OP_BT_STOP) {
  233. mUiHandler.sendEmptyMessage(UI_BT_CLOSE);
  234. // do stop
  235. if (mDumpStart == true) {
  236. if (mBtTest != null) {
  237. Xlog.i(TAG, "pollingStop");
  238. mBtTest.pollingStop();
  239. }
  240. }
  241. if (RETURN_FAIL == mBtTest.doBtTest(BT_TEST_3)) {
  242. Xlog.i(TAG, "stop failed.");
  243. }
  244. mBtTest = null;
  245. mUiHandler.sendEmptyMessage(UI_BT_CLOSE_FINISHED);
  246. }
  247. }
  248. }
  249.  
  250. public boolean onPrepareOptionsMenu(Menu menu) {
  251. MenuItem doneItem = menu.getItem(Menu.FIRST - 1);
  252. if (null != doneItem) {
  253. if (!mDoneTest) {
  254. doneItem.setEnabled(false);
  255. menu.close();
  256. } else {
  257. doneItem.setEnabled(true);
  258. }
  259. } else {
  260. Xlog.i(TAG, "menu_done is not found.");
  261. }
  262. return true;
  263. }
  264.  
  265. /**
  266. * Initialize the UI component
  267. *
  268. *
  269. */
  270. protected void setValuesSpinner() {
  271. // for TX pattern
  272. mPattern = (Spinner) findViewById(R.id.PatternSpinner);
  273. ArrayAdapter<CharSequence> adapterPattern = ArrayAdapter
  274. .createFromResource(this, R.array.tx_pattern,
  275. android.R.layout.simple_spinner_item);
  276. adapterPattern
  277. .setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item);
  278. mPattern.setAdapter(adapterPattern);
  279.  
  280. // for TX channels
  281. mChannels = (Spinner) findViewById(R.id.ChannelsSpinner);
  282. ArrayAdapter<CharSequence> adapterChannels = ArrayAdapter
  283. .createFromResource(this, R.array.tx_channels,
  284. android.R.layout.simple_spinner_item);
  285. adapterChannels
  286. .setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item);
  287. mChannels.setAdapter(adapterChannels);
  288.  
  289. // for TX pocket type
  290. mPktTypes = (Spinner) findViewById(R.id.PocketTypeSpinner);
  291. ArrayAdapter<CharSequence> adapterPocketType = ArrayAdapter
  292. .createFromResource(this, R.array.tx_Pocket_type,
  293. android.R.layout.simple_spinner_item);
  294. adapterPocketType
  295. .setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item);
  296. mPktTypes.setAdapter(adapterPocketType);
  297. }
  298.  
  299. @Override
  300. public boolean onCreateOptionsMenu(Menu menu) {
  301. super.onCreateOptionsMenu(menu);
  302.  
  303. MenuInflater inflater = getMenuInflater();
  304. inflater.inflate(R.menu.menu_show, menu);
  305. return true;
  306. }
  307.  
  308. @Override
  309. public boolean onOptionsItemSelected(MenuItem item) {
  310. switch (item.getItemId()) {
  311. case R.id.menu_done:
  312. // edited by chaozhogn @ 2010-10-10
  313. // return doSendCommandAction();
  314. Xlog.i(TAG, "menu_done is clicked.");
  315. if (mDoneTest) {
  316. // if the last click action has been handled, send another event
  317. // request
  318. // mWorkHandler.post(new WorkRunnable());
  319. mWorkHandler.sendEmptyMessage(OP_BT_SEND);
  320. } else {
  321. Xlog.i(TAG, "last click is not finished yet.");
  322. }
  323. Xlog.i(TAG, "menu_done is handled.");
  324. return true;
  325. // edit end
  326.  
  327. case R.id.menu_discard:
  328. return doRevertAction();
  329. default:
  330. break;
  331. }
  332. return false;
  333. }
  334.  
  335. /**
  336. * Send command the user has made, and finish the activity.
  337. */
  338. private boolean doSendCommandAction() {
  339. getBtState();
  340. enableBluetooth(false);
  341. getValuesAndSend();
  342. return true;
  343. }
  344.  
  345. // implemented for DialogInterface.OnCancelListener
  346. public void onCancel(DialogInterface dialog) {
  347. // request that the service stop the query with this callback
  348. // mBtTestect.
  349. Xlog.v(TAG, "-->onCancel");
  350. finish();
  351. }
  352.  
  353. @Override
  354. protected void onStart() {
  355. super.onStart();
  356. Xlog.v(TAG, "-->onStart");
  357. if (mAdapter == null) {
  358. mAdapter = BluetoothAdapter.getDefaultAdapter();
  359. }
  360. if (mAdapter.getState() != BluetoothAdapter.STATE_OFF) {
  361. showDialog(CHECK_BT_STATE);
  362. }
  363. // if (mAdapter != null) {
  364. // if (mAdapter.getState() != BluetoothAdapter.STATE_OFF) {
  365. // showDialog(CHECK_BT_STATE);
  366. // }
  367. // } else {
  368. // showDialog(CHECK_BT_DEVEICE);
  369. // }
  370. }
  371.  
  372.  
  373. @Override
  374. public void onBackPressed() {
  375. Xlog.v(TAG, "-->onBackPressed ");
  376. removeDialog(TEST_TX);
  377. if (mBtTest != null) {
  378. mWorkHandler.sendEmptyMessage(OP_BT_STOP);
  379. } else {
  380. super.onBackPressed();
  381. }
  382. }
  383. @Override
  384. public void onDestroy() {
  385. Xlog.v(TAG, "-->onDestroy");
  386. if (mWorkThread != null) {
  387. mWorkThread.quit();
  388. }
  389. super.onDestroy();
  390. }
  391.  
  392. @Override
  393. protected Dialog onCreateDialog(int id) {
  394. Xlog.i(TAG, "-->onCreateDialog");
  395. if (id == TEST_TX) {
  396. ProgressDialog dialog = new ProgressDialog(this);
  397. dialog.setMessage(getString(R.string.BT_init_dev));
  398. dialog.setCancelable(false);
  399. dialog.setIndeterminate(true);
  400. Xlog.i(TAG, "new ProgressDialog succeed");
  401. return dialog;
  402. } else if (id == CHECK_BT_STATE) {
  403. AlertDialog dialog = null;
  404. AlertDialog.Builder builder = new AlertDialog.Builder(this);
  405. builder.setCancelable(false);
  406. builder.setTitle(R.string.Error);
  407. builder.setMessage(R.string.BT_turn_bt_off);
  408. builder.setPositiveButton(R.string.OK,
  409. new DialogInterface.OnClickListener() {
  410. public void onClick(DialogInterface dialog, int which) {
  411. finish();
  412. }
  413. });
  414. dialog = builder.create();
  415. return dialog;
  416. } else if (id == DIALOG_BT_STOP) {
  417. ProgressDialog dialog = new ProgressDialog(this);
  418. dialog.setMessage(getString(R.string.BT_deinit));
  419. dialog.setCancelable(false);
  420. dialog.setIndeterminate(true);
  421. // dialog.show();
  422. return dialog;
  423. }
  424. return null;
  425. }
  426.  
  427. private void getBtState() {
  428. Xlog.v(TAG, "Enter GetBtState().");
  429. BluetoothAdapter btAdapter = BluetoothAdapter.getDefaultAdapter();
  430. if (null == btAdapter) {
  431. Xlog.i(TAG, "we can not find a bluetooth adapter.");
  432. // Toast.makeText(getApplicationContext(),
  433. // "We can not find a bluetooth adapter.", Toast.LENGTH_SHORT)
  434. // .show();
  435. mUiHandler.sendEmptyMessage(OP_TX_FAIL);
  436. return;
  437. }
  438. mStateBt = btAdapter.getState();
  439. Xlog.i(TAG, "Leave GetBtState().");
  440. }
  441.  
  442. private void enableBluetooth(boolean enable) {
  443. Xlog.v(TAG, "Enter EnableBluetooth().");
  444. BluetoothAdapter btAdapter = BluetoothAdapter.getDefaultAdapter();
  445. if (null == btAdapter) {
  446. Xlog.i(TAG, "we can not find a bluetooth adapter.");
  447. return;
  448. }
  449. // need to enable
  450. if (enable) {
  451. Xlog.i(TAG, "Bluetooth is enabled");
  452. btAdapter.enable();
  453. } else {
  454. // need to disable
  455. Xlog.i(TAG, "Bluetooth is disabled");
  456. btAdapter.disable();
  457. }
  458. Xlog.i(TAG, "Leave EnableBluetooth().");
  459. }
  460.  
  461. /**
  462. * Revert any changes the user has made, and finish the activity.
  463. */
  464. private boolean doRevertAction() {
  465. //finish();
  466. Xlog.i(TAG, "doRevertAction");
  467. onBackPressed();
  468. return true;
  469. }
  470.  
  471. // private BtTest mBtTest = null;
  472.  
  473. public void getValuesAndSend() {
  474. Xlog.i(TAG, "Enter GetValuesAndSend().");
  475. mBtTest = new BtTest();
  476.  
  477. getSpinnerValue(mPattern, MAP_TO_PATTERN);
  478. getSpinnerValue(mChannels, MAP_TO_CHANNELS);
  479. getSpinnerValue(mPktTypes, MAP_TO_POCKET_TYPE);
  480.  
  481. getEditBoxValue(R.id.edtFrequency, MAP_TO_FREQ);
  482. getEditBoxValue(R.id.edtPocketLength, MAP_TO_POCKET_TYPE_LEN);
  483.  
  484. // send command to....
  485. // new issue added by mtk54040 Shuaiqiang @2011-10-12
  486. Xlog.i(TAG, "PocketType().+" + mBtTest.getPocketType());
  487. Xlog.i(TAG, "edtFrequency+" + mBtTest.getFreq());
  488. if (27 == mBtTest.getPocketType()) {
  489. Xlog.i(TAG, "enter handleNonModulated(mBtTest)");
  490. Xlog.i(TAG, "mbIsNonModulate--" + mNonModulate
  491. + " mbIsPocketType--" + mPocketType);
  492. if (mPocketType) { // mbIsPocketType for avoid mBtTest is null
  493. runHCIResetCmd();
  494. }
  495. if (initBtTestOjbect()) {
  496. mNonModulate = true;
  497. mPocketType = false;
  498. // handleNonModulated(mBtTest);
  499. handleNonModulated();
  500. }
  501.  
  502. } else {
  503. if (mNonModulate) {
  504. runHCIResetCmd();
  505. mNonModulate = false;
  506. }
  507. mPocketType = true;
  508. if (RETURN_FAIL == mBtTest.doBtTest(BT_TEST_0)) {
  509. Xlog.i(TAG, "transmit data failed.");
  510. if ((BluetoothAdapter.STATE_TURNING_ON == mStateBt)
  511. || (BluetoothAdapter.STATE_ON == mStateBt)) {
  512. enableBluetooth(true);
  513. }
  514. // Toast.makeText(getApplicationContext(),
  515. // "transmit data failed.", Toast.LENGTH_SHORT).show();
  516. mUiHandler.sendEmptyMessage(OP_TX_FAIL);
  517. mHasInit = false;
  518. } else {
  519. mHasInit = true;
  520. }
  521. }
  522. Xlog.i(TAG, "Leave getValuesAndSend().");
  523. }
  524.  
  525. private void handleNonModulated() {
  526. Xlog.i(TAG, "-->handleNonModulated TX first");
  527. /*
  528. * If pressing "Stop" button Tx: 01 0C 20 02 00 PP 0xPP = Filter
  529. * Duplicate (00 = Disable Duplicate Filtering, 01 = Enable Duplicate
  530. * Filtering) Rx: 04 0E 04 01 0C 20 00
  531. */
  532.  
  533. /*
  534. * TX: 01 15 FC 01 00 RX: 04 0E 04 01 15 FC 00 TX: 01 D5 FC 01 XX (XX =
  535. * Channel) RX: 04 0E 04 01 D5 FC 00
  536. */
  537. int cmdLen = 5;
  538. char[] cmd = new char[cmdLen];
  539. char[] response = null;
  540. int i = 0;
  541. cmd[0] = 0x01;
  542. cmd[1] = 0x15;
  543. cmd[2] = 0xFC;
  544. cmd[3] = 0x01;
  545. cmd[4] = 0x00;
  546. response = mBtTest.hciCommandRun(cmd, cmdLen);
  547. if (response != null) {
  548. String s = null;
  549. for (i = 0; i < response.length; i++) {
  550. s = String.format("response[%d] = 0x%x", i, (long) response[i]);
  551. Xlog.i(TAG, s);
  552. }
  553. } else {
  554. Xlog.i(TAG, "HCICommandRun failed");
  555. }
  556. response = null;
  557.  
  558. Xlog.i(TAG, "-->handleNonModulated TX second");
  559. cmdLen = 5;
  560. cmd[0] = 0x01;
  561. cmd[1] = 0xD5;
  562. cmd[2] = 0xFC;
  563. cmd[3] = 0x01;
  564. cmd[4] = (char) mBtTest.getFreq();
  565. response = mBtTest.hciCommandRun(cmd, cmdLen);
  566. if (response != null) {
  567. String s = null;
  568. for (i = 0; i < response.length; i++) {
  569. s = String.format("response[%d] = 0x%x", i, (long) response[i]);
  570. Xlog.i(TAG, s);
  571. }
  572. } else {
  573. Xlog.i(TAG, "HCICommandRun failed");
  574. }
  575. response = null;
  576. }
  577.  
  578. // init BtTest -call init function of BtTest
  579. private boolean initBtTestOjbect() {
  580. Xlog.i(TAG, "-->initBtTestOjbect");
  581. if (mIniting) {
  582. return false;
  583. }
  584. if (mHasInit) {
  585. return mHasInit;
  586. }
  587. if (mBtTest == null) {
  588. mBtTest = new BtTest();
  589. }
  590. if (mBtTest != null && !mHasInit) {
  591. mIniting = true;
  592. if (mBtTest.init() != 0) {
  593. mHasInit = false;
  594. Xlog.i(TAG, "mBtTest initialization failed");
  595. } else {
  596. runHCIResetCmd();
  597. mHasInit = true;
  598. }
  599. }
  600. mIniting = false;
  601. return mHasInit;
  602. }
  603.  
  604. // clear BtTest mBtTestect -call deInit function of BtTest
  605. // private boolean uninitBtTestOjbect() {
  606. // Xlog.i(TAG, "-->uninitBtTestOjbect");
  607. // if (mBtTest != null && mbIsInit) {
  608. // runHCIResetCmd();
  609. // if (mBtTest.unInit() != 0) {
  610. // Xlog.i(TAG, "mBtTest un-initialization failed");
  611. // }
  612. // }
  613. // mBtTest = null;
  614. // mbIsInit = false;
  615. // return true;
  616. // }
  617.  
  618. // run "HCI Reset" command
  619. private void runHCIResetCmd() {
  620. /*
  621. * If pressing "HCI Reset" button Tx: 01 03 0C 00 Rx: 04 0E 04 01 03 0C
  622. * 00 After pressing "HCI Reset" button, all state will also be reset
  623. */
  624. int cmdLen = 4;
  625. char[] cmd = new char[cmdLen];
  626.  
  627. char[] response = null;
  628. int i = 0;
  629. Xlog.i(TAG, "-->runHCIResetCmd");
  630. cmd[0] = 0x01;
  631. cmd[1] = 0x03;
  632. cmd[2] = 0x0C;
  633. cmd[3] = 0x00;
  634. if (mBtTest == null) {
  635. mBtTest = new BtTest();
  636. }
  637. response = mBtTest.hciCommandRun(cmd, cmdLen);
  638. if (response != null) {
  639. String s = null;
  640. for (i = 0; i < response.length; i++) {
  641. s = String.format("response[%d] = 0x%x", i, (long) response[i]);
  642. Xlog.i(TAG, s);
  643. }
  644. } else {
  645. Xlog.i(TAG, "HCICommandRun failed");
  646. }
  647. response = null;
  648. }
  649.  
  650. private boolean getSpinnerValue(Spinner sSpinner, int flag) {
  651. boolean bSuccess = false;
  652. int index = sSpinner.getSelectedItemPosition();
  653. if (0 > index) {
  654. return bSuccess;
  655. }
  656.  
  657. switch (flag) {
  658. case MAP_TO_PATTERN: // Pattern
  659. mBtTest.setPatter(index);
  660. break;
  661. case MAP_TO_CHANNELS: // Channels
  662. mBtTest.setChannels(index);
  663. break;
  664. case MAP_TO_POCKET_TYPE: // Pocket type
  665. mBtTest.setPocketType(index);
  666. break;
  667. default:
  668. bSuccess = false;
  669. break;
  670. }
  671. bSuccess = true;
  672. return bSuccess;
  673. }
  674.  
  675. private boolean getEditBoxValue(int id, int flag) {
  676. boolean bSuccess = false;
  677.  
  678. TextView text = (TextView) findViewById(id);
  679. String str = null;
  680. if (null != text) {
  681. str = text.getText().toString();
  682. }
  683. if ((null == str) || str.equals("")) {
  684. return bSuccess;
  685. }
  686. int iLen = 0;
  687. try {
  688. iLen = Integer.parseInt(str);
  689. } catch (NumberFormatException e) {
  690. Xlog.i(TAG, "parseInt failed--invalid number!");
  691. return bSuccess;
  692. }
  693. // frequency
  694. if (MAP_TO_FREQ == flag) {
  695. mBtTest.setFreq(iLen);
  696. bSuccess = true;
  697. } else if (MAP_TO_POCKET_TYPE_LEN == flag) {
  698. // pocket type length
  699. mBtTest.setPocketTypeLen(iLen);
  700. bSuccess = true;
  701. }
  702. return bSuccess;
  703. }
  704. }
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!