getparcelableextra 用法

getparcelableextra用法getParcelableExtra方法是用于获取从Intent中传递的Parcelable 对象的方法。

Parcelable是一个Android特有的接口，用于在不同组件之间传递自定义对象。

使用getParcelableExtra方法的前提是，首先在发送Intent的地方将Parcelable对象添加到Intent中。

可以使用putExtra方法来添加Parcelable对象。

例如，在Activity A中，我们创建一个Parcelable对象并将其添加到Intent中：```ParcelableObj obj = new ParcelableObj(;Intent intent = new Intent(this, ActivityB.class);intent.putExtra("parcelable_obj", obj);startActivity(intent);```然后，在Activity B中，我们可以使用getParcelableExtra方法来获取传递过来的Parcelable对象：```ParcelableObj obj =getIntent(.getParcelableExtra("parcelable_obj");getParcelableExtra方法接收一个字符串参数，该参数是之前在putExtra方法中添加Parcelable对象时所使用的键值。

通过这个键值，我们可以在接收方获取到正确的Parcelable对象。

需要注意的是，getParcelableExtra方法返回的是一个Parcelable 对象，需要进行类型转换才能使用其中的方法和属性。

另外，如果Intent中没有传递Parcelable对象，或者没有使用指定键值来传递Parcelable对象，那么getParcelableExtra方法将返回null。

extra的用法总结大全（学习版）编制人：__________________审核人：__________________审批人：__________________编制学校：__________________编制时间：____年____月____日序言下载提示：该文档是本店铺精心编制而成的，希望大家下载后，能够帮助大家解决实际问题。

文档下载后可定制修改，请根据实际需要进行调整和使用，谢谢!并且，本店铺为大家提供各种类型的经典范文，如英语单词、英语语法、英语听力、英语知识点、语文知识点、文言文、数学公式、数学知识点、作文大全、其他资料等等，想了解不同范文格式和写法，敬请关注!Download tips: This document is carefully compiled by this editor.I hope that after you download it, it can help you solve practical problems. The document can be customized and modified after downloading, please adjust and use it according to actual needs, thank you!In addition, this shop provides various types of classic sample essays, such as English words, English grammar, English listening, English knowledge points, Chinese knowledge points, classical Chinese, mathematical formulas, mathematics knowledge points, composition books, other materials, etc. Learn about the different formats and writing styles of sample essays, so stay tuned!extra的用法总结大全extra的意思adj. 额外的，补充的，附加的,特大的，特别的n. 附加物，额外的事物,临时演员,号外,上等产品，上品adv. 额外地,格外地，特别地extra用法extra可以用作形容词extra的基本意思是“外加的”,常指数量上的增加或价格方面“另外收费的”。

⼿机蓝⽛检测蓝⽛设备信号强度（RSSI）蓝⽛（ Bluetooth® ）：是⼀种⽆线技术标准，可实现固定设备、移动设备和楼宇个⼈域⽹之间的短距离数据交换（使⽤2.4—2.485GHz的ISM波段的UHF⽆线电波）。

蓝⽛技术最初由电信巨头爱⽴信公司于1994年创制，当时是作为RS232数据线的替代⽅案。

蓝⽛可连接多个设备，克服了数据同步的难题。

RSSI:Received Signal Strength Indication接收的信号强度指⽰，⽆线发送层的可选部分，⽤来判定链接质量，以及是否增⼤⼴播发送强度。

通过接收到的信号强弱测定信号点与接收点的距离，进⽽根据相应数据进⾏定位计算的⼀种定位技术。

本例是通过⼿机蓝⽛对周围蓝⽛设备进⾏搜索，显⽰出域⽤户输⼊的蓝⽛设备名称相匹配的远程蓝⽛设备的信号强度（RSSI）。

所需权限：<uses-permission android:name="android.permission.BLUETOOTH"/><uses-permission android:name="android.permission.BLUETOOTH_ADMIN"/><uses-permission android:name="android.permission.BLUETOOTH_PRIVILEGED"/>布局⽂件activity_main.xml：<TextViewandroid:id="@+id/showRssi"android:layout_width="wrap_content"android:layout_height="wrap_content"android:text="hello_man"/><Buttonandroid:id="@+id/open"android:layout_width="wrap_content"android:layout_height="wrap_content"android:layout_alignLeft="@+id/showRssi"android:layout_below="@+id/showRssi"android:layout_marginTop="24dp"android:onClick="open"android:text="打开蓝⽛"/><Buttonandroid:id="@+id/close"android:onClick="close"android:layout_width="wrap_content"android:layout_height="wrap_content"android:layout_alignBaseline="@+id/open"android:layout_alignBottom="@+id/open"android:layout_centerHorizontal="true"android:text="关闭蓝⽛"/><EditTextandroid:id="@+id/bluetoothName"android:layout_width="wrap_content"android:layout_height="wrap_content"android:layout_below="@+id/open"android:layout_marginTop="31dp"android:ems="10"android:hint="请输⼊蓝⽛名称"><requestFocus /></EditText><Buttonandroid:id="@+id/show"android:onClick="show"android:layout_width="wrap_content"android:layout_height="wrap_content"android:layout_alignBaseline="@+id/close"android:layout_alignBottom="@+id/close"android:layout_alignParentRight="true"android:text="信号强度"/>布局图：布局为三个按钮，⼀个textview，⼀个editview。

Android 通过两种模式来支持各种 USB 外设和 Android USB 配件（指那些符合 Android 附件协议的 硬件） ：USB 配件和 USB 主机。

在 USB 配件的模式之下，外部的 USB 配件就像 USB 主机那样。

这 种配件可以包括机器人控制器，基站连接器，医疗和音乐设备，电话亭以及读卡器这样很多的设备。

这样就使得那些搭载 Android 系统的设备不需要具备主机的特性就可以和 USB 硬件进行交互。

Android USB 配件是指那些专门用来为搭载 Android 系统的设备工作以及符合 Android 附件通信协议 的设备。

在 USB 主机的模式之下， 搭载 Android 的设备就像主机那样工作。

这些设备包括数码相机， 键盘，鼠标以及游戏控制器。

Android USB 设备被设计成具有广泛的应用领域，可以很好的完成人机 互动应用的通信设备。

图 1 就显示了这两种模式的区别。

当搭载 Android 系统的设备处于主机的模式下,它就充当 USB 主机 并且为总线提供能源。

而当搭载 Android 系统的设备处于 USB 配件的模式下时,连接的 USB 硬件(这 种情况下,指的是一个 Android USB 配件)作为主机一样并且为总线提供能源。

在 Android3.1（API12 级）或较新的平台直接支持 USB 配件和主机模式。

USB 配件模式以一个附加 的类库的方式支持范围更广的设备 被移植到 Android 2.3.4(API10 级)。

设备生产商可以决定是否在 系统镜像上附加这个类库。

注意:支持 USB 主机和配件模式主要取决于设备的硬件,而不是平台的等级。

你可以通过一个 [[<uses-feature>]]元素来为设备进行过滤以支持 USB 主机和配件。

看这个 USB 配件和主机文档来 了解更多的详情。

调试注意事项当用 USB 主机或者配件调试应用程序时，你最好有连接到搭载 Android 程序的设备的 USB 硬件。

读取NfcA格式数据如何读取数据？Tag tagFromIntent = intent.getParcelableExtra(NfcAdapter.EXTRA_TAG);NfcA nfcA = NfcA.get(tag);nfcA.connect();byte[] SELECT = {(byte) 0x30, (byte) 0x05};//我读取的NFC卡⽚使⽤的是NTAG216的芯⽚，这⾥的指令参数是根据其datasheet的说明写的。

byte[] result = nfcA.transceive(SELECT);//这⾥会返回16个字节的数据，根据芯⽚不同会有差异该芯⽚的快速读写命令是0x3A，可以指定读取页数范围，在使⽤快速读写命令时，发现读取范围超过70字节android就会报错，所以使⽤了每次最多读取64字节的⽅式。

package com.yorkg.android.nfc;import java.io.IOException;import java.io.UnsupportedEncodingException;import java.util.ArrayList;import java.util.Arrays;import android.app.Activity;import android.app.AlertDialog;import android.app.PendingIntent;import android.content.DialogInterface;import android.content.Intent;import android.content.IntentFilter;import android.nfc.NfcAdapter;import android.nfc.Tag;import android.nfc.tech.MifareClassic;import android.nfc.tech.NfcA;import android.os.Bundle;import android.view.View;import android.view.View.OnClickListener;import android.view.Window;import android.widget.Button;import android.widget.EditText;import android.widget.Toast;import com.yorkg.android.nfc.dataobject.mifare.MifareBlock;import com.yorkg.android.nfc.dataobject.mifare.MifareClassCard;import com.yorkg.android.nfc.dataobject.mifare.MifareSector;import com.yorkg.android.nfc.util.Converter;public class MyFirstNFCDemoActivity extends Activity {/** Called when the activity is first created. */private Button clearBtn = null;private EditText sealCompanyName = null;private EditText sealName = null;private EditText sealNumber = null;private EditText sealTaxId = null;private EditText sealCode = null;private EditText sealMaterial = null;private EditText sealSize = null;private EditText companyMadedName = null;private EditText companyMadedTime = null;private EditText companyCheckedName = null;private NfcAdapter mAdapter;private PendingIntent mPendingIntent;private IntentFilter[] mFilters;private String[][] mTechLists;private static final int AUTH = 1;private static final int EMPTY_BLOCK_0 = 2;private static final int EMPTY_BLOCK_1 = 3;private static final int NETWORK = 4;private static final int NFC_OFF = 5;private static final int NFC_TYPE_ERROR = 6;private static final String TAG = "NfcDemo";private static boolean READ_LOCK = false;private void initView(){sealCompanyName = (EditText) this.findViewById(R.id.edittext_seal_company_name);sealName = (EditText) this.findViewById(R.id.edittext_seal_name);sealNumber = (EditText) this.findViewById(R.id.edittext_seal_number);sealTaxId = (EditText) this.findViewById(R.id.edittext_tax_id);sealCode = (EditText) this.findViewById(R.id.edittext_code);sealMaterial = (EditText) this.findViewById(R.id.edittext_seal_material);sealSize = (EditText) this.findViewById(R.id.edittext_seal_size);companyMadedName = (EditText) this.findViewById(R.id.edittext_company_maded_name);companyMadedTime = (EditText) this.findViewById(R.id.edittext_company_maded_time);companyCheckedName = (EditText) this.findViewById(R.id.edittext_company_checked_name);clearBtn = (Button) this.findViewById(R.id.clear_btn);clearBtn.setOnClickListener(new OnClickListener() {@Overridepublic void onClick(View v) {// TODO Auto-generated method stubcleanData();}});}//清除数据信息private void cleanData(){sealCompanyName.setText("");sealName.setText("");sealNumber.setText("");sealTaxId.setText("");sealCode.setText("");sealMaterial.setText("");sealSize.setText("");companyMadedName.setText("");companyMadedTime.setText("");companyCheckedName.setText("");}@Overridepublic void onCreate(Bundle savedState) {super.onCreate(savedState);requestWindowFeature(Window.FEATURE_NO_TITLE);setContentView(yout.main);initView();mAdapter = NfcAdapter.getDefaultAdapter(this);mPendingIntent = PendingIntent.getActivity(this, 0, new Intent(this,getClass()).addFlags(Intent.FLAG_ACTIVITY_SINGLE_TOP), 0); // Setup an intent filter for all MIME based dispatchesIntentFilter ndef = new IntentFilter(NfcAdapter.ACTION_TECH_DISCOVERED);// try {// ndef.addDataType("*/*");// } catch (MalformedMimeTypeException e) {// throw new RuntimeException("fail", e);// }mFilters = new IntentFilter[] { ndef, };mTechLists = new String[][] { new String[] { MifareClassic.class.getName() } , new String[] {NfcA.class.getName()}};//得到是否检测到ACTION_TECH_DISCOVERED触发if (NfcAdapter.ACTION_TECH_DISCOVERED.equals(getIntent().getAction())) {//处理该intentresolveIntentNfcA(getIntent());}}@Overridepublic void onResume() {super.onResume();if (mAdapter!=null && (!mAdapter.isEnabled())) {showAlert(NFC_OFF, getString(R.string.error5));}if (mAdapter!=null) {mAdapter.enableForegroundDispatch(this, mPendingIntent, mFilters,mTechLists);}}@Overridepublic void onNewIntent(Intent intent) {resolveIntentNfcA(intent);}@Overridepublic void onPause() {super.onPause();if (mAdapter!=null){mAdapter.disableForegroundDispatch(this);}}void resolveIntentNfcA(Intent intent){if (READ_LOCK==false){READ_LOCK = true;Tag tag = intent.getParcelableExtra(NfcAdapter.EXTRA_TAG);if (NfcAdapter.ACTION_TECH_DISCOVERED.equals(intent.getAction())){Tag tagFromIntent = intent.getParcelableExtra(NfcAdapter.EXTRA_TAG); MyLog.i(TAG, Arrays.toString(tagFromIntent.getTechList()));try{NfcA nfcA = NfcA.get(tag);nfcA.connect();byte[] SELECT = {(byte) 0x30,(byte) 0x05,};byte[] result = nfcA.transceive(SELECT);int data_len = ((result[0]&0x0f)<<8)+((result[1]&0xff));MyLog.i(TAG, "是否已写⼊数据"+result[0]+"，写⼊数据长度："+data_len); byte[] buf_res = new byte[data_len/2+4];if (result[0]!=0 && data_len!=0){int count = data_len/2/64;int i = 0;for (i=0; i<count; i++){// //读取数据byte[] DATA_READ = {(byte) 0x3A,(byte) (0x06+i*(64/4)),(byte) (0x06+(i+1)*(64/4))// (byte) (5+data_len/8)};byte[] data_res = nfcA.transceive(DATA_READ);System.arraycopy(data_res, 0, buf_res, i*64, 64);MyLog.i(TAG, "读卡成功");}if (((data_len/2)%(64))!=0){byte[]DATA_READ = {(byte) 0x3A,(byte) (0x06+i*(64/4)),(byte) (((0x06+i*(64/4))+(data_len/2/4)%(64/4))-1)// (byte) (5+data_len/8)};byte[] data_res = nfcA.transceive(DATA_READ);System.arraycopy(data_res, 0, buf_res, i*64, (data_len/2)%64);MyLog.i(TAG, "读卡成功2");}String res = gb2312ToString(buf_res);MyLog.i(TAG, "stringBytes:"+res);showNFCInfo(res);}}catch(IOException e){e.printStackTrace();cleanData();MyLog.e(TAG, "读卡失败");}catch (Exception e) {// TODO: handle exceptione.printStackTrace();showAlert(NFC_TYPE_ERROR, getString(R.string.error6));}finally{}}READ_LOCK = false;}}//将数据转换为GB2312private String gb2312ToString(byte[] data) {String str = null;try {str = new String(data, "gb2312");//"utf-8"} catch (UnsupportedEncodingException e) {}return str;}//将字符串解析显⽰到页⾯private void showNFCInfo(String str){String[] contents_temp = str.split("\\|");String[] contents = new String[contents_temp.length];int i;for (i = 0; i < contents_temp.length; i++) {contents[i]=contents_temp[i];}//⽬前有10项，所以这⾥只初始化到第10项for (int j=i; j<10; j++){contents[j]="";}if (contents[0]!=null){sealCompanyName.setText(contents[0]);}if (contents[1]!=null){sealName.setText(contents[1]);}if (contents[2]!=null){sealNumber.setText(contents[2]);}if (contents[3]!=null){sealTaxId.setText(contents[3]);}if (contents[4]!=null){sealCode.setText(contents[4]);}if (contents[5]!=null){sealMaterial.setText(contents[5]);}if (contents[6]!=null){sealSize.setText(contents[6]);}if (contents[7]!=null){companyMadedName.setText(contents[7]);}if (contents[8]!=null){companyMadedTime.setText(contents[8]);}if (contents[9]!=null){companyCheckedName.setText(contents[9]);}}private void showAlert(int alertCase,String str) {// prepare the alert boxAlertDialog.Builder alertbox = new AlertDialog.Builder(this); switch (alertCase) {case AUTH:// Card Authentication Erroralertbox.setMessage(getString(R.string.error1));break;case EMPTY_BLOCK_0: // Block 0 Emptyalertbox.setMessage(getString(R.string.error2));break;case EMPTY_BLOCK_1:// Block 1 Emptyalertbox.setMessage(getString(R.string.error3));break;case NETWORK: // Communication Erroralertbox.setMessage(getString(R.string.error4));break;case NFC_OFF:alertbox.setMessage(getString(R.string.error5));break;case NFC_TYPE_ERROR:alertbox.setMessage(getString(R.string.error6));}// set a positive/yes button and create a listeneralertbox.setPositiveButton("OK", new DialogInterface.OnClickListener() { // Save the data from the UI to the database - already donepublic void onClick(DialogInterface arg0, int arg1) {clearFields();}});// display boxalertbox.show();}private void clearFields() {}}。

Androidusb设备权限查询及⾃动获取详解流程看到当上⾯的对话框弹出时，可以使⽤命令查看顶层的活动窗⼝adb shell dumpsys window | findstr mCurrentFocusmCurrentFocus=Window{41ab0ee0 u0 com.android.systemui/bPermissionActivity}这就是应⽤的位置，当然我们也可以是⽤grep命令来查找这个对话框的.xml⽂件，进⼊android源码然后输⼊命令：grep '默认情况下⽤于' ./ -Rn./SystemUI/res/values-zh-rCN/strings.xml:51: <string name="always_use_device" msgid="1450287437017315906">"默认情况下⽤于该 USB 设备"</string>./SystemUI/res/values-zh-rCN/strings.xml:52: <string name="always_use_accessory" msgid="1210954576979621596">"默认情况下⽤于该 USB 配件"</string>那么这个对话框的路径在/android/frameworks/base/packages/SystemUI/res/values-zh-rCN/strings.xml其相关的内容如下：<string name="always_use_device" msgid="1450287437017315906">"默认情况下⽤于该 USB 设备"</string><string name="usb_device_permission_prompt" msgid="834698001271562057">"允许应⽤“<xliff:g id="APPLICATION">%1$s</xliff:g>”访问该 USB 设备吗？"相关应⽤路径找到.java⽂件来修改，其位置在:/android/frameworks/base/packages/SystemUI/src/com/android/systemui/usb/UsbPermissionActivity.java这就是那个讨厌的对话框对应的java程序，那么来看看这个程序如下：/** Copyright (C) 2011 The Android Open Source Project** Licensed under the Apache License, Version 2.0 (the "License");* you may not use this file except in compliance with the License.* You may obtain a copy of the License at** /licenses/LICENSE-2.0** Unless required by applicable law or agreed to in writing, software* distributed under the License is distributed on an "AS IS" BASIS,* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.* See the License for the specific language governing permissions and* limitations under the License.*/package b;import android.app.AlertDialog;import android.app.PendingIntent;import android.content.Context;import android.content.DialogInterface;import android.content.Intent;import android.content.pm.ApplicationInfo;import android.content.pm.PackageManager;import b.IUsbManager;import bAccessory;import bDevice;import bManager;import android.os.Bundle;import android.os.IBinder;import android.os.RemoteException;import android.os.ServiceManager;import erHandle;import android.util.Log;import youtInflater;import android.view.View;import android.widget.CheckBox;import poundButton;import android.widget.TextView;import com.android.internal.app.AlertActivity;import com.android.internal.app.AlertController;import com.android.systemui.R;public class UsbPermissionActivity extends AlertActivityimplements DialogInterface.OnClickListener, CheckBox.OnCheckedChangeListener {private static final String TAG = "UsbPermissionActivity";private CheckBox mAlwaysUse;private TextView mClearDefaultHint;private UsbDevice mDevice;private UsbAccessory mAccessory;private PendingIntent mPendingIntent;private String mPackageName;private int mUid;private boolean mPermissionGranted;private UsbDisconnectedReceiver mDisconnectedReceiver;@Overridepublic void onCreate(Bundle icicle) {super.onCreate(icicle);Intent intent = getIntent();mDevice = (UsbDevice)intent.getParcelableExtra(UsbManager.EXTRA_DEVICE);mAccessory = (UsbAccessory)intent.getParcelableExtra(UsbManager.EXTRA_ACCESSORY); mPendingIntent = (PendingIntent)intent.getParcelableExtra(Intent.EXTRA_INTENT);mUid = intent.getIntExtra(Intent.EXTRA_UID, -1);mPackageName = intent.getStringExtra("package");Log.e(TAG, "mPackageName "+ mPackageName);Log.e(TAG, "mUid "+ mUid);PackageManager packageManager = getPackageManager();ApplicationInfo aInfo;try {aInfo = packageManager.getApplicationInfo(mPackageName, 0);} catch (NotFoundException e) {Log.e(TAG, "unable to look up package name", e);finish();return;}String appName = aInfo.loadLabel(packageManager).toString();Log.e(TAG, "appName "+ appName);final AlertController.AlertParams ap = mAlertParams;ap.mIcon = aInfo.loadIcon(packageManager);ap.mTitle = appName;if (mDevice == null) {ap.mMessage = getString(b_accessory_permission_prompt, appName);mDisconnectedReceiver = new UsbDisconnectedReceiver(this, mAccessory);} else {ap.mMessage = getString(b_device_permission_prompt, appName);mDisconnectedReceiver = new UsbDisconnectedReceiver(this, mDevice);}ap.mPositiveButtonText = getString(android.R.string.ok);ap.mNegativeButtonText = getString(android.R.string.cancel);ap.mPositiveButtonListener = this;ap.mNegativeButtonListener = this;// add "always use" checkboxLayoutInflater inflater = (LayoutInflater)getSystemService(YOUT_INFLATER_SERVICE);ap.mView = inflater.inflate(yout.always_use_checkbox, null);mAlwaysUse = (CheckBox)ap.mView.findViewById(com.android.internal.R.id.alwaysUse);if (mDevice == null) {mAlwaysUse.setText(R.string.always_use_accessory);} else {mAlwaysUse.setText(R.string.always_use_device);}mAlwaysUse.setOnCheckedChangeListener(this);mClearDefaultHint = (TextView)ap.mView.findViewById(com.android.internal.R.id.clearDefaultHint);mClearDefaultHint.setVisibility(View.GONE);if(!mPackageName.equals("bcamera"))setupAlert();else{mPermissionGranted = true;finish();}}@Overridepublic void onDestroy() {IBinder b = ServiceManager.getService(USB_SERVICE);IUsbManager service = IUsbManager.Stub.asInterface(b);// send response via pending intentIntent intent = new Intent();try {if (mDevice != null) {intent.putExtra(UsbManager.EXTRA_DEVICE, mDevice);if (mPermissionGranted) {service.grantDevicePermission(mDevice, mUid);if (mAlwaysUse.isChecked()) {final int userId = UserHandle.getUserId(mUid);service.setDevicePackage(mDevice, mPackageName, userId);}}}if (mAccessory != null) {intent.putExtra(UsbManager.EXTRA_ACCESSORY, mAccessory);if (mPermissionGranted) {service.grantAccessoryPermission(mAccessory, mUid);if (mAlwaysUse.isChecked()) {final int userId = UserHandle.getUserId(mUid);service.setAccessoryPackage(mAccessory, mPackageName, userId);}}}intent.putExtra(UsbManager.EXTRA_PERMISSION_GRANTED, mPermissionGranted); mPendingIntent.send(this, 0, intent);} catch (PendingIntent.CanceledException e) {Log.w(TAG, "PendingIntent was cancelled");} catch (RemoteException e) {Log.e(TAG, "IUsbService connection failed", e);}if (mDisconnectedReceiver != null) {unregisterReceiver(mDisconnectedReceiver);}super.onDestroy();}public void onClick(DialogInterface dialog, int which) {if (which == AlertDialog.BUTTON_POSITIVE) {mPermissionGranted = true;}finish();}public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) {if (mClearDefaultHint == null) return;if(isChecked) {mClearDefaultHint.setVisibility(View.VISIBLE);} else {mClearDefaultHint.setVisibility(View.GONE);}}}这段代码是获取应⽤的包名，我们可以通过包名对⽐来决定是否弹出对话框。

getserializableextra 警告-回复什么是getSerializableExtra警告？在Android开发中，我们经常需要在不同的Activity之间传递数据。

Intent 是一种常用的机制，用于在不同的组件之间传递数据。

通过putExtra方法，我们可以将数据附加到Intent上，然后在目标Activity中使用getExtra 方法来检索数据。

然而，当我们在Intent中传递自定义对象时，我们需要使用getSerializableExtra方法来获取该对象。

然而，有时候Android Studio会给出一个警告，提示我们进行一些更改。

这个警告就是"getSerializableExtra警告"。

为什么会出现getSerializableExtra警告？getSerializableExtra警告是Android Studio的一项功能，旨在帮助开发者改进代码质量和性能。

当我们使用getSerializableExtra方法获取自定义对象时，有时会发生序列化或反序列化问题，导致潜在的慢速性能或内存泄漏问题。

因此，Android Studio会给出这个警告，以提醒开发者进行必要的更改来避免这些问题。

如何解决getSerializableExtra警告？要解决getSerializableExtra警告，我们可以使用更安全和高效的方式传递自定义对象。

以下是一些步骤，可以帮助我们逐步解决这个警告。

第一步：了解警告内容首先，我们需要仔细阅读警告以了解其内容。

警告通常包括一些技术细节和建议，可以帮助我们确定问题的根源。

第二步：考虑使用Parcelable接口替代Serializable接口Android提供了两种主要的对象传递方式：Serializable和Parcelable。

虽然Serializable是更常见的选择，但Parcelable接口在性能方面更为优秀。

activity之间传递数据的方式及常见问题总结在应用程序开发中，一个应用可能包含多个Activity，它们之间可能需要传递数据。

下面总结了Activity之间传递数据的方式及常见问题：一、Intent传递数据Intent是Android中最常用的传递数据的方式，它可以在不同的Activity之间传递数据。

通过Intent传递数据有两种方式：1. putExtra()方法使用putExtra()方法可以将数据打包到Intent中，然后在目标Activity中获取数据。

例如，在Activity A中传递一个字符串到Activity B：//在Activity A中String data = 'Hello, Activity B';Intent intent = new Intent(this, ActivityB.class);intent.putExtra('extra_data', data);startActivity(intent);//在Activity B中Intent intent = getIntent();String data = intent.getStringExtra('extra_data');2. Parcelable方式如果需要传递自定义的对象，可以使用Parcelable方式。

该方式需要实现Parcelable接口，重写里面的方法，并在Intent中将对象打包，然后在目标Activity中获取对象。

例如：//在Activity A中Person person = new Person('Tom', 18);Intent intent = new Intent(this, ActivityB.class);intent.putExtra('extra_person', person);startActivity(intent);//在Activity B中Intent intent = getIntent();Person person =intent.getParcelableExtra('extra_person');二、静态变量传递数据如果需要在多个Activity之间传递数据，可以使用静态变量。

Android开发实现NFC刷卡读取的两种⽅式场景：NFC是⽬前Android⼿机⼀个主流的配置硬件项，本⽂主要讲解⼀下Android开发中，NFC刷卡的两种实现⽅式以及相关⽅法源码解析。

①：Manifest注册⽅式：这种⽅式主要是在Manifest⽂件对应的activity下，配置过滤器，以响应不同类型NFC Action。

使⽤这种⽅式，在刷卡时，如果⼿机中有多个应⽤都存在该NFC实现⽅案，系统会弹出能响应NFC事件的应⽤列表供⽤户选择，⽤户需要点击⽬标应⽤来响应本次NFC刷卡事件。

⽬前我公司这边项⽬中使⽤了该逻辑，⽐较简便，这⾥先贴⼀下该⽅式的实现逻辑。

Manifest配置：<!--权限要加，这是⼀个普通权限，不需要动态申请，但是在⼩⽶⼿机⾥需要动态申请--><uses-permission android:name="android.permission.NFC" /><uses-featureandroid:name="android.hardware.nfc"android:required="false" /><application>...<activityandroid:name=".NfcActivity"android:launchMode="singleTask"android:screenOrientation="portrait"android:theme="@android:style/Theme.Translucent"><!--透明主题，把刷卡变成⼀个⽆感知的过程--><intent-filter><action android:name="android.nfc.action.NDEF_DISCOVERED" /></intent-filter><intent-filter><action android:name="android.nfc.action.TAG_DISCOVERED" /><category android:name="android.intent.category.DEFAULT" /></intent-filter><intent-filter><action android:name="android.nfc.action.TECH_DISCOVERED" /><!--使⽤这个过滤器这⾥其实还要⽤ meta-data 配置⼀下标签过滤，--><!--我项⽬中是 NDEF_DISCOVERED 这个TECH_DISCOVERED形同虚设--></intent-filter><meta-dataandroid:name="android.nfc.action.TECH_DISCOVERED"android:resource="@xml/nfc_tech" /></activity></application>nfc_tech.xml：这个⽂件就是TECH_DISCOVERED需要配置的，其中，tech-list之间是逻辑或关系，tech之间是逻辑与关系，与⽅案②中的techLists原理以及⽤途是类似的。

java storagevolume 创建方法-回复Java是一种基于对象的编程语言，被广泛应用于软件开发和互联网应用领域。

在Java中，StorageVolume是用于表示存储卷的类。

它提供了一系列方法和属性，用于管理和操作存储卷。

本文将详细介绍StorageVolume 类的创建方法和使用场景。

一、什么是StorageVolume类Java的StorageVolume类位于android.os.storage包中，用于表示存储卷。

存储卷可以是设备的物理存储空间，也可以是虚拟的存储空间，比如外部SD卡或USB存储设备。

StorageVolume类包含了一些操作和属性，例如获取存储卷路径、获取存储卷名称等。

二、创建StorageVolume对象的方法创建StorageVolume对象的方法有多种。

根据具体的使用场景和需求，我们可以选择不同的方法创建StorageVolume对象。

下面将逐步介绍这些方法。

1. 使用Context类的getSystemService方法在Android应用中，我们可以使用Context类的getSystemService方法来获取系统服务的实例。

对于StorageVolume类，我们可以通过该方法获取StorageManager对象，再通过StorageManager对象的getStorageVolumes方法获取StorageVolume对象的列表。

示例代码如下：Context context = getApplicationContext();StorageManager storageManager = (StorageManager) context.getSystemService(Context.STORAGE_SERVICE);List<StorageVolume> storageVolumes =storageManager.getStorageVolumes();2. 使用Intent类和StorageVolume.EXTRA_STORAGE_VOLUME另一种创建StorageVolume对象的方法是使用Intent类和StorageVolume.EXTRA_STORAGE_VOLUME。

Android中Intent传递对象的3种⽅式详解前⾔相信Intent的⽤法⼤家已经⽐较熟悉了，Intent可以⽤来启动Activity，Service等等，同时我们也可以通过Intent来进⾏传递数据，当我们使⽤Intent在Activity 间传递信息时发现putExtra()⽅法并不⽀持⾃定义对象的传输，下⾯就来介绍三种解决⽅式。

⼀、Serializable ⽅式这是最简单的⼀种⽅法，因为我们要做的就是让我们⾃定义的对象实现 Serializable 这个空接⼝。

public class Person implements Serializable{private String mName;private String mAddress;public String getName() {return mName;}public void setName(String name) {mName = name;}public String getAddress() {return mAddress;}public void setAddress(String address) {mAddress = address;}}这个时候，就已经可以使⽤Intent 的putExtra() ⽅法传递这个⾃定义对象了，在Activity中这样使⽤Person person = new Person();person.setName("Hwaphon");person.setAddress("Anhui");Intent intent = new Intent(MainActivity.this,SecondActivity.class);intent.putExtra("person",person);startActivity(intent);finish();在Activity中接收数据Intent intent = getIntent();Person person = (Person) intent.getSerializableExtra("person");使⽤Serializable⽅法虽然⼗分简单，但是效率却不容乐观，因为它会把整个对象序列化，开销⼗分⼤，为了追求效率，我们不得不使⽤另⼀种⽅法，也就是Parcelable ⽅法。

对于Android的英文帮助文档，总是看了记不住，远不如对中文资料那么印象深，所以下面的叙述都是对Android帮助文档Bluetooth的翻译。

一、BluetoothAndroid平台包含了对Bluetooth协议栈的支持，允许机器通过Bluetooth设备进行无线数据交换。

应用框架通过Android Bluetooth API访问Bluetooth功能模块。

这些API能让应用无线连接其他Bluetooth设备，实现点对点和多点之间的通信。

运用蓝牙API，Android应用程序可以完成如下操作：1、扫描其他Bluetooth设备。

2、查询配对Bluetooth设备的本地Bluetooth适配器。

3、建立RFCOMM通道。

4、通过服务探索连接到其他设备。

5、与其他设备进行数据传输。

6、管理多个连接二、The Basics本文描述如何使用Android Bluetooth APIs完成Bluetooth通讯的4个必要任务：设置Bluetooth，搜寻本地配对或者可用的Bluetooth设备，连接Bluetooth设备，与Bluetooth 设备进行数据传输。

所有可用的Bluetooth APIs都包含在android.bluetooth包中。

下面是建立Bluetooth连接需要用到的类和接口的总结：1、BluetoothAdapter描述本地Bluetooth适配器（Bluetooth接收器）。

BluetoothAdapter是所有Bluetooth相关活动的入口。

运用BluetoothAdapter可以发现其他Bluetooth设备，查询连接（或配对）的设备列表，用已知MAC地址实例化一个BluetoothDevice对象，创建一个BluetoothServerSocket对象侦听其他设备的通信。

2、BluetoothDevice描述一个远程Bluetooth设备。

可以用它通过一个BluetoothSocket请求一个远程设备的连接，或者查询远程设备的名称、地址、类、连接状态等信息。

Android蓝⽛连接ESCPOS热敏打印机打印实例（蓝⽛连接篇）公司的⼀个⼿机端的 CRM 项⽬最近要增加⼩票打印的功能，就是我们点外卖的时候经常会见到的那种⼩票。

这⾥主要涉及到两⼤块的知识：1. 蓝⽛连接及数据传输2. ESC/POS 打印指令蓝⽛连接不⽤说了，太常见了，这篇主要介绍这部分的内容。

但ESC/POS 打印指令是个什么⿁？简单说，我们常见的热敏⼩票打印机都⽀持这样⼀种指令，只要按照指令的格式向打印机发送指令，哪怕是不同型号品牌的打印机也会执⾏相同的动作。

⽐如打印⼀⾏⽂本，换⾏，加粗等都有对应的指令，这部分内容放在下⼀篇介绍。

本篇主要基于，相⽐官⽅⽂档，省去了⼤段的说明，更加便于快速上⼿。

1. 蓝⽛权限想要使⽤蓝⽛功能，⾸先要在 AndroidManifest 配置⽂件中声明蓝⽛权限：<manifest><uses-permission android:name="android.permission.BLUETOOTH" /><uses-permission android:name="android.permission.BLUETOOTH_ADMIN" />...</manifest>BLUETOOTH 权限只允许建⽴蓝⽛连接以及传输数据，但是如果要进⾏蓝⽛设备发现等操作的话，还需要申请BLUETOOTH_ADMIN 权限。

2. 初始配置这⾥主要⽤到⼀个类。

⽤法很简单，直接看代码：BluetoothAdapter mBluetoothAdapter = BluetoothAdapter.getDefaultAdapter();if (mBluetoothAdapter == null) {// Device does not support Bluetooth}单例模式，全局只有⼀个实例，只要为 null，就代表设备不⽀持蓝⽛，那么需要有相应的处理。

Android⼿机通过蓝⽛连接佳博打印机的实例代码所使⽤的打印机为佳博打印机，⽀持蓝⽛、wifi、usb我所使⽤的是通过蓝⽛来连接。

在⽹上找到⼀个佳博官⽅针对安卓开发的App源码，但是各种的跳转，没有看太懂，所以⼜去问度娘，找到了⼀个不错的⽂章Android对于蓝⽛开发从2.0版本的sdk才开始⽀持，⽽且模拟器不⽀持，测试⾄少需要两部⼿机，所以制约了很多技术⼈员的开发。

1. ⾸先，要操作蓝⽛，先要在AndroidManifest.xml⾥加⼊权限// 管理蓝⽛设备的权限<uses-permissionandroid:name="android.permission.BLUETOOTH_ADMIN" />// 使⽤蓝⽛设备的权限<uses-permissionandroid:name="android.permission.BLUETOOTH" />2.打开蓝⽛获得蓝⽛适配器（android.bluetooth.BluetoothAdapter），检查该设备是否⽀持蓝⽛，如果⽀持，就打开蓝⽛。

// 检查设备是否⽀持蓝⽛adapter = BluetoothAdapter.getDefaultAdapter();if (adapter == null){// 设备不⽀持蓝⽛}// 打开蓝⽛if (!adapter.isEnabled()){Intent intent = new Intent(BluetoothAdapter.ACTION_REQUEST_ENABLE);// 设置蓝⽛可见性，最多300秒intent.putExtra(BluetoothAdapter.EXTRA_DISCOVERABLE_DURATION,300);context.startActivity(intent);}3.获取已配对的蓝⽛设备（android.bluetooth.BluetoothDevice）⾸次连接某蓝⽛设备需要先配对，⼀旦配对成功，该设备的信息会被保存，以后连接时⽆需再配对，所以已配对的设备不⼀定是能连接的。

getbluetoothdevices的返回值一、概述getBluetoothDevices()是Android平台中的一个方法，用于获取已配对或正在扫描的蓝牙设备列表。

该方法返回一个包含BluetoothDevice对象的List集合。

二、返回值类型List<BluetoothDevice>三、返回值说明1. 如果当前设备没有进行蓝牙配对，则返回空列表。

2. 如果当前设备已经进行了蓝牙配对，则返回已配对的蓝牙设备列表。

3. 如果当前设备正在扫描周围的蓝牙设备，则返回扫描到的蓝牙设备列表。

四、使用方法示例1. 获取已配对的蓝牙设备列表：```BluetoothAdapter mBluetoothAdapter = BluetoothAdapter.getDefaultAdapter();List<BluetoothDevice> pairedDevices = new ArrayList<>();Set<BluetoothDevice> devices = mBluetoothAdapter.getBondedDevices();if (devices.size() > 0) {for (BluetoothDevice device : devices) {pairedDevices.add(device);}}```2. 获取正在扫描的蓝牙设备列表：```final List<BluetoothDevice> scanDevices = new ArrayList<>(); final BluetoothAdapter mBluetoothAdapter = BluetoothAdapter.getDefaultAdapter(); mBluetoothAdapter.startDiscovery(); BroadcastReceiver mReceiver = new BroadcastReceiver() {public void onReceive(Context context, Intent intent) {String action = intent.getAction();if (BluetoothDevice.ACTION_FOUND.equals(action)) {BluetoothDevice device =intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE);scanDevices.add(device);}}};IntentFilter filter = newIntentFilter(BluetoothDevice.ACTION_FOUND); registerReceiver(mReceiver, filter);```五、注意事项1. 在使用getBluetoothDevices()方法之前，需要先检查蓝牙是否可用，并且需要获取蓝牙适配器对象。

Android中Parcelable的使⽤详解Parcelable与SerializableSerializable是Java为我们提供的⼀个标准化的序列化接⼝。

Parcelable是Android为我们提供的序列化的接⼝。

对⽐：1、Parcelable相对于Serializable的使⽤相对复杂⼀些。

2、Parcelable的效率相对Serializable也⾼很多。

3、Parcelable不能使⽤在要将数据存储在磁盘上的情况，因为Parcelable在外界有变化的情况下不能很好的保证数据的持续性。

尽管Serializable效率低点，但此时还是建议使⽤Serializable。

存储到设备或者⽹络传输上选择Serializable。

序列化与反序列化序列化：将对象转换为可以传输的⼆进制流(⼆进制序列)的过程,这样我们就可以通过序列化,转化为可以在⽹络传输或者保存到本地的流(序列),从⽽进⾏传输数据。

反序列化：从⼆进制流(序列)转化为对象的过程。

简单使⽤：进⾏Android开发的时候，⽆法将对象的引⽤传给Activities或者Fragments，我们需要将这些对象放到⼀个Intent或者Bundle⾥⾯，然后再传递。

简单看⼀下：1、定义Book类，实现Parcelable接⼝。

package com.status.mattest;import android.os.Parcel;import android.os.Parcelable;public class Book implements Parcelable {private String name;private int id;private String classify;protected Book(Parcel in) {name = in.readString();classify = in.readString();id = in.readInt();}public Book(String classify, String name, int id) { = name;this.id = id;this.classify = classify;}/*** 反序列化*/public static final Creator<Book> CREATOR = new Creator<Book>() {@Overridepublic Book createFromParcel(Parcel in) {return new Book(in);}@Overridepublic Book[] newArray(int size) {return new Book[size];}};@Overridepublic int describeContents() {return 0;}/*** 序列化过程** @param dest* @param flags*/@Overridepublic void writeToParcel(Parcel dest, int flags) {dest.writeString(name);dest.writeString(classify);dest.writeInt(id);}@Overridepublic String toString() {return "name : " +name + "\"" + "id : " + id + "\"" + "classify" + classify;}}writeToParcel：序列化过程Creator与protected Book(Parcel in)配合实现反序列化，转换为对象。

getserializableextra 获取不到数据时的返回值问题：getSerializableExtra 获取不到数据时的返回值在Android开发中，我们经常会使用Intent来进行Activity之间的数据传递。

其中一个常见的方法是通过putExtra和getSerializableExtra来传递和获取Serializable类型的数据。

但是有时候我们会遇到一个问题，就是当我们调用getSerializableExtra时，如果没有找到对应的数据，它会返回什么值呢？事实上，当我们调用getSerializableExtra方法获取Serializable数据的时候，如果没有找到对应的数据，它会返回null。

这个null值表示没有找到对应的数据。

那么为什么会返回null呢？这是因为getSerializableExtra方法是通过键值对的方式来获取数据的，当我们调用putExtra方法将数据放入Intent 中时，会以键值对的形式存储起来。

然后当我们调用getSerializableExtra 方法时，它会根据传入的键来查找对应的值。

如果找不到对应的值，那么就会返回null。

那么当我们获取到null值时，应该如何处理呢？首先，我们需要明确一点，就是获取到null值并不一定意味着出错。

有时候，null值可能是预期的结果。

例如，在某些情况下，我们可能会根据某些条件来判断是否需要传递数据，如果不满足条件，就不会putExtra 数据到Intent 中。

在这种情况下，我们在获取数据时，如果返回null，那就表示没有满足条件需要传递的数据。

然而，在某些情况下，我们可能会期望获取到数据，但是得到了null值。

这可能是因为我们传递数据的时候出了问题。

下面是一些常见的原因和解决方法：1. 检查键是否正确首先，我们需要确保调用getSerializableExtra方法时传入的键值是正确的。

由于键值对是以字符串的形式存储的，因此大小写也是敏感的。

getserializableextra 获取不到数据时的返回值-回复什么是getSerializableExtra方法？getSerializableExtra方法是Android中Intent类的一个方法，用于从Intent对象中获取一个Serializable类型的数据。

Serializable是Java中一个接口，被用于表示一个类的对象可以被序列化，即可以在网络中传输或存储到磁盘上。

因此，getSerializableExtra方法允许我们从一个Activity或者Fragment传递一个可序列化的对象到另一个Activity或者Fragment中。

为什么会无法获取到数据？在某些情况下，我们可能会发现getSerializableExtra方法无法获取到数据，返回的值是null。

有以下几个常见的原因导致无法获取到数据：1. 序列化类的定义发生了变化：如果在传递数据的时候，序列化类的定义发生了变化，比如删除了某个字段或者添加了新的字段，那么接收方就无法正确地还原传递的数据对象。

2. 序列化类更改了包名或者路径：如果序列化类被移动到不同的包名或者路径下，那么接收方将无法正确地找到类的定义，因此无法正确地反序列化。

3. 传递的数据为空对象：在传递数据的过程中，如果传递的数据对象是一个空对象，那么接收方获取到的数据仍然是空对象。

4. 数据类型不匹配：如果传递的数据类型与接收方期望的数据类型不匹配，那么获取数据的过程将会失败。

如何处理无法获取到数据的情况？当无法获取到数据时，我们可以采取以下方法进行处理：1. 检查传递的数据是否为空对象：在接收方处理获取数据的过程中，首先应该对获取到的数据进行非空判断。

可以通过使用if语句或者null安全调用（?.）来检查数据是否为空。

2. 检查传递的类定义是否发生了变化：如果传递的数据对象的定义发生了变化，那么接收方需要保证类的定义与传递方一致。

可以通过查看类的定义和日志文件来确定是否有变化，并进行相应的处理，比如更新类的定义或者转换数据类型。