Android ListView EditText批量录入功能

最新推荐文章于 2021-05-27 11:05:25 发布
最新推荐文章于 2021-05-27 11:05:25 发布
阅读量1.2k 收藏 1
点赞数
CC 4.0 BY-SA版权
分类专栏： Android
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/crystalddd/article/details/48214001
                   最近工作中有一个批量录入的功能，使用的是ListView + EditText组合。由于业务的需要，所以需要自己编写一个符合我们业务需求的软键盘。
    刚好Android 中也提供了自定义键盘。经过一些案例，自定义键盘ok啦！但是ListView上的edittext使用自定义键盘，那么焦点输入没法像系统软键盘一样快速定位显示输入的文本。此时有一种方案，那就是ListView对应的适配器提供一个回调接口，将我们点击触发的edittext对象传递给KeyboardView（自定义键盘）对象。这个是否就可以将自定义键盘输入的文本快速显示到点击触发的edittext文本框上。这里思路就介绍到这里了，下面就请大家看代码吧！


main.xml  :

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent"
    android:orientation="vertical" >
    
    <ListView 
        android:id="@+id/lv_demo"
        android:layout_weight="1"
        android:layout_width="match_parent"
        android:dividerHeight="1dp"
        android:divider="@android:color/white"
        android:layout_height="match_parent"
        />
 
     <android.inputmethodservice.KeyboardView
                    android:id="@+id/keyboard_view"
                    android:layout_width="match_parent"
                    android:layout_height="wrap_content"
                    android:background="@drawable/keyboard_bg"
                    android:focusable="true"
                    android:focusableInTouchMode="true"
                    android:keyBackground="@drawable/new_keyboard_bg"
                    android:keyTextColor="#000000"
                    android:layout_weight="0"
                    android:visibility="gone" />
</LinearLayout> 


KeydemoActivity :

public class KeydemoActivity extends Activity{
    
    private static final String TAG = KeydemoActivity.class.getSimpleName();
    private Context ctx;
    private Activity act;
    private ListView lvDemo;
     
    private ListEditorAdapter adapter;
     
    private KeyboardView keyboard_view;
     
    /**
     * 上一个edittext
     */
    private EditText preEdit;
     
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
        lvDemo = (ListView) findViewById(R.id.lv_demo);
        keyboard_view = (KeyboardView) findViewById(R.id.keyboard_view);
        ctx = this;
        act = this;
    
        KeyObj ko1 = new KeyObj();
        ko1.setName("crystal1");
        ko1.setValue("1");
        ko1.setValue2("2");
        
        KeyObj ko2 = new KeyObj();
        ko2.setName("crystal2");
        ko2.setValue("2");
        ko2.setValue2("4");
        
        
        KeyObj ko3 = new KeyObj();
        ko3.setName("crystal3");
        ko3.setValue("3");
        ko3.setValue2("6");
        
        KeyObj ko4 = new KeyObj();
        ko4.setName("crystal4");
        ko4.setValue("4");
        ko4.setValue2("8");
        
        KeyObj ko5 = new KeyObj();
        ko5.setName("crystal5");
        ko5.setValue("5");
        ko5.setValue2("10");
        
        KeyObj ko6 = new KeyObj();
        ko6.setName("crystal6");
        ko6.setValue("6");
        ko6.setValue2("12");
        
        KeyObj ko7 = new KeyObj();
        ko7.setName("crystal7");
        ko7.setValue("7");
        ko7.setValue2("14");
        
        Map<String,Object> map = new HashMap<String, Object>();
        map.put("crystal1", ko1);
        map.put("crystal2", ko2);
        map.put("crystal3", ko3);
        map.put("crystal4", ko4);
        map.put("crystal5", ko5);
        map.put("crystal6", ko6);
        map.put("crystal7", ko7);
        
        List<String> list = new ArrayList<String>();
        list.add("crystal1");
        list.add("crystal2");
        list.add("crystal3");
        list.add("crystal4");
        list.add("crystal5");
        list.add("crystal6");
        list.add("crystal7");
    
        adapter = new ListEditorAdapter(KeydemoActivity.this, map,list);
        lvDemo.setAdapter(adapter);
        
        adapter.setItemListener(new ListEditorAdapter.ItemOnClickListener() {
            
            @Override
            public void itemOnClickListener(View view) {
                if(preEdit != null)                                                 preEdit.setBackgroundDrawable(getResources().getDrawable(R.drawable.bg_edittext_normal));
}
EditText edit = (EditText) view;
          edit.setBackgroundDrawable(getResources().getDrawable(R.drawable.bg_edittext_focused));
                new KeyboardUtil(keyboard_view, KeydemoActivity.this, edit).showKeyboard();
                preEdit = edit;
            }
        });
    }
} 


KeyObj:

public class KeyObj {
    private String name;
    private String value;
    private String value2;
    
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getValue() {
        return value;
    }
    public void setValue(String value) {
        this.value = value;
    }
    public String getValue2() {
        return value2;
    }
    public void setValue2(String value2) {
        this.value2 = value2;
    }
}


ListEditorAdapter  ：

public class ListEditorAdapter extends BaseAdapter {
    private static final String TAG = ListEditorAdapter.class.getSimpleName();
    private Context mContext;
    private LayoutInflater mInflater;
    private ViewHolder holder = null;
    private Map<String,Object> map;
    private List<String> list;
    
    public ListEditorAdapter(Context context, Map<String,Object> paramMap,List<String> paramList) {
        this.mContext = context;
        this.map = paramMap;
        this.list = paramList;
        mInflater = LayoutInflater.from(context);
    }
    @Override
    public int getCount() {
        return list.size();
    }
    @Override
    public Object getItem(int position) {
        return null;
    }
    @Override
    public long getItemId(int position) {
        return 0;
    }
    private Integer index = -1;
    @Override
    public View getView(int position, View convertView, ViewGroup parent) {
        if (convertView == null) {
            holder = new ViewHolder();
            convertView = mInflater.inflate(R.layout.listview_item, null);
            holder.name = (TextView) convertView
                    .findViewById(R.id.name);
            holder.value = (EditText) convertView
                    .findViewById(R.id.value);
            holder.value2 = (EditText) convertView
                    .findViewById(R.id.value2);
            holder.value.setTag(position);
            holder.value2.setTag(position);
            
            class MyTextWatcher implements TextWatcher {
                public MyTextWatcher(ViewHolder holder) {
                    mHolder = holder;
                }
                private ViewHolder mHolder;
                @Override
                public void onTextChanged(CharSequence s, int start,
                        int before, int count) {
                }
                @Override
                public void beforeTextChanged(CharSequence s, int start,
                        int count, int after) {
                }
                @Override
                public void afterTextChanged(Editable s) {
                    if (s != null && !"".equals(s.toString())) {
                        int position = (Integer) mHolder.value.getTag();
                        String key = list.get(position);
                        if(map.containsKey(key)){
                            ((KeyObj)map.get(key)).setValue(s.toString());
                        }else{
                            KeyObj ko = new KeyObj();
                            ko.setName(key);
                            ko.setValue(s.toString());
                            map.put(key, ko);
                        }
                    }
                }
            }
            class MyTextWatcher2 implements TextWatcher {
                
                public MyTextWatcher2(ViewHolder holder) {
                    mHolder = holder;
                }
                private ViewHolder mHolder;
                @Override
                public void onTextChanged(CharSequence s, int start,
                        int before, int count) {
                }
                @Override
                public void beforeTextChanged(CharSequence s, int start,
                        int count, int after) {
                }
                @Override
                public void afterTextChanged(Editable s) {
                    if (s != null && !"".equals(s.toString())) {
                        int position = (Integer) mHolder.value2.getTag();
                        String key = list.get(position);
                        if(map.containsKey(key)){
                            ((KeyObj)map.get(key)).setValue2(s.toString());
                        }else{
                            KeyObj ko = new KeyObj();
                            ko.setName(key);
                            ko.setValue2(s.toString());
                            map.put(key, ko);
                        }
                    }
                }
            }
            
            holder.value.addTextChangedListener(new MyTextWatcher(holder));
            holder.value2.addTextChangedListener(new MyTextWatcher2(holder));
            convertView.setTag(holder);
        } else {
            holder = (ViewHolder) convertView.getTag();
            holder.value.setTag(position);
            holder.value2.setTag(position);
        }
        
        
        String name = ((KeyObj)map.get(list.get(position))).getName();
        if (name != null) {
            holder.name.setText((String) name);
        }
        
        String value = ((KeyObj)map.get(list.get(position))).getValue();
        if (value != null) {
            holder.value.setText((String) value);
        }
        
        String value2 = ((KeyObj)map.get(list.get(position))).getValue2();
        if (value2 != null) {
            holder.value2.setText((String) value2);
        }
        holder.value.setOnClickListener(IClicklistener);
        holder.value2.setOnClickListener(IClicklistener);
        return convertView;
    }
    
       //此处定义接口，提供给activity回调，获取点击的edittext对象，传递给自定义键盘KeyboardView
    private OnClickListener IClicklistener = new OnClickListener() {
        @Override
        public void onClick(View v) {
            mOnClickListener.itemOnClickListener(v);
        }
    };
    
    private ItemOnClickListener mOnClickListener;
    public void setItemListener(ItemOnClickListener listener) {
        mOnClickListener = listener;
    }
    
    public interface ItemOnClickListener {
        void itemOnClickListener(View view);
    }
    
    public class ViewHolder {
        public TextView name;
        public EditText value; // ListView中的输入
        public EditText value2; // ListView中的输入
    }
    
    
} 



KeyboardUtil  ：

public class KeyboardUtil {
    /*private Activity mActivity;*/
    @SuppressWarnings("unused")
    private Context mContext;
    @SuppressWarnings("unused")
    private KeyboardView keyboardView;
    private Keyboard keyAlp;// 字母键盘
    private Keyboard keyDig;// 数字键盘
    private Keyboard k3;// 符号键盘
    public boolean isnun = false;// 是否数字键盘
    public boolean isupper = false;// 是否大写
    private EditText ed;
    
    public KeyboardUtil(KeyboardView kbView,Context mContext, EditText edit) {
        this.mContext = mContext;
        this.ed = edit;
        keyAlp = new Keyboard(mContext, R.xml.qwerty);
        keyDig = new Keyboard(mContext, R.xml.symbols);
        k3 = new Keyboard(mContext, R.xml.sign);
        this.keyboardView = kbView;
        keyboardView.setKeyboard(keyDig);
        keyboardView.setEnabled(true);
        keyboardView.setPreviewEnabled(true);
        keyboardView.setOnKeyboardActionListener(listener);
    }
    private OnKeyboardActionListener listener = new OnKeyboardActionListener() {
        @Override
        public void swipeUp() {
        }
        @Override
        public void swipeRight() {
        }
        @Override
        public void swipeLeft() {
        }
        @Override
        public void swipeDown() {
        }
        @Override
        public void onText(CharSequence text) {
        }
        @Override
        public void onRelease(int primaryCode) {
        }
        @Override
        public void onPress(int primaryCode) {
        }
        @Override
        public void onKey(int primaryCode, int[] keyCodes) {
            Editable editable = ed.getText();
            ed.setSelection(editable.length());
            int start = ed.getSelectionStart();
            if (primaryCode == Keyboard.KEYCODE_CANCEL) {// 完成
                ed.setBackgroundDrawable(mContext.getResources().getDrawable(R.drawable.bg_edittext_normal));
                hideKeyboard();
            } else if (primaryCode == Keyboard.KEYCODE_DELETE) {// 回退
                if (!TextUtils.isEmpty(editable)) {
                    if (start > 0) {
                        editable.delete(start - 1, start);
                    }
                }
            } else if (primaryCode == Keyboard.KEYCODE_SHIFT) {// 大小写切换
                changeKey();
                keyboardView.setKeyboard(keyAlp);
            } else if (primaryCode == Keyboard.KEYCODE_MODE_CHANGE) {// 数字键盘切换
                if (isnun) {
                    isnun = false;
                    keyboardView.setKeyboard(keyAlp);
                } else {
                    isnun = true;
                    randomdigkey();
                }
            }else if(primaryCode == -999){
                keyboardView.setKeyboard(k3);
            }else {
                editable.insert(start, Character.toString((char) primaryCode));
            }
        }
    };
    /**
     * 键盘大小写切换
     */
    private void changeKey() {
        List<Key> keylist = keyAlp.getKeys();
        if (isupper) {// 大写切换小写
            isupper = false;
            for (Key key : keylist) {
                if (key.label != null && isword(key.label.toString())) {
                    key.label = key.label.toString().toLowerCase();
                    key.codes[0] = key.codes[0] + 32;
                }
            }
        } else {// 小写切换大写
            isupper = true;
            for (Key key : keylist) {
                if (key.label != null && isword(key.label.toString())) {
                    key.label = key.label.toString().toUpperCase();
                    key.codes[0] = key.codes[0] - 32;
                }
            }
        }
    }
    public void showKeyboard() {
        int visibility = keyboardView.getVisibility();
        if (visibility == View.GONE || visibility == View.INVISIBLE) {
            keyboardView.setVisibility(View.VISIBLE);
        }
    }
    public void hideKeyboard() {
        int visibility = keyboardView.getVisibility();
        if (visibility == View.VISIBLE) {
            keyboardView.setVisibility(View.GONE);
        }
    }
    private boolean isNumber(String str) {
        String wordstr = "0123456789";
        if (wordstr.indexOf(str) > -1) {
            return true;
        }
        return false;
    }
    private boolean isword(String str) {
        String wordstr = "abcdefghijklmnopqrstuvwxyz";
        if (wordstr.indexOf(str.toLowerCase()) > -1) {
            return true;
        }
        return false;
    }
    private void randomdigkey(){
        List<Key> keyList = keyDig.getKeys();
        // 查找出0-9的数字键
        List<Key> newkeyList = new ArrayList<Key>();
        for (int i = 0; i < keyList.size(); i++) {
            if (keyList.get(i).label != null
                    && isNumber(keyList.get(i).label.toString())) {
                newkeyList.add(keyList.get(i));
            }
        }
        // 数组长度
        int count = newkeyList.size();
        // 结果集
        List<KeyModel> resultList = new ArrayList<KeyModel>();
        // 用一个LinkedList作为中介
        LinkedList<KeyModel> temp = new LinkedList<KeyModel>();
        // 初始化temp
        for (int i = 0; i < count; i++) {
            temp.add(new KeyModel(48 + i, i + ""));
        }
        // 取数
        Random rand = new Random();
        for (int i = 0; i < count; i++) {
            int num = rand.nextInt(count - i);
            resultList.add(new KeyModel(temp.get(num).getCode(),
                    temp.get(num).getLable()));
            temp.remove(num);
        }
        for (int i = 0; i < newkeyList.size(); i++) {
            newkeyList.get(i).label = resultList.get(i).getLable();
            newkeyList.get(i).codes[0] = resultList.get(i)
                    .getCode();
        }
        keyboardView.setKeyboard(keyDig);
    }
    private void randomalpkey(){
        List<Key> keyList = keyAlp.getKeys();
        // 查找出a-z的数字键
        List<Key> newkeyList = new ArrayList<Key>();
        for (int i = 0; i < keyList.size(); i++) {
            if (keyList.get(i).label != null
                    && isword(keyList.get(i).label.toString())) {
                newkeyList.add(keyList.get(i));
            }
        }
        // 数组长度
        int count = newkeyList.size();
        // 结果集
        List<KeyModel> resultList = new ArrayList<KeyModel>();
        // 用一个LinkedList作为中介
        LinkedList<KeyModel> temp = new LinkedList<KeyModel>();
        // 初始化temp
        for (int i = 0; i < count; i++) {
            temp.add(new KeyModel(97 + i, "" + (char) (97 + i)));
        }
        // 取数
        Random rand = new Random();
        for (int i = 0; i < count; i++) {
            int num = rand.nextInt(count - i);
            resultList.add(new KeyModel(temp.get(num).getCode(),
                    temp.get(num).getLable()));
            temp.remove(num);
        }
        for (int i = 0; i < newkeyList.size(); i++) {
            newkeyList.get(i).label = resultList.get(i).getLable();
            newkeyList.get(i).codes[0] = resultList.get(i)
                    .getCode();
        }
        keyboardView.setKeyboard(keyAlp);
    }
}


 
源码：

android listview，ExpandableListView实现单选，多选，全选，edittext实现批量输入
08-01
android listview，ExpandableListView实现单选，多选，全选，edittext实现批量输入
android listview edittext 不能输入,android – 无法在expandable listview中输入edittext
weixin_30636329的博客
05-27 675
我正在使用包含2个不同子项的可扩展ListView.子布局包含3个EditText字段.当我展开组时,它会显示子布局,但我无法在edittext字段中键入任何文本.我在自定义可扩展列表适配器中的代码如下：public View getChildView(int groupPosition, int childPosition, boolean arg2, View childView,ViewGr...
Android ListView的Item中带EditText的全输入和全取消输入
qq_26349681的博客
01-04 461
上代码： 1、MainActicity.class public class MainActivity extends AppCompatActivity implements View.OnClickListener{ ImageView imgMulti; ListView mList; TextView tvSave; String priceTit
scrollview+edittext实现批量输入效果
wangwo1991的博客
08-11 579
在（android listview ExpandableListView实现多选，单选，全选，edittext实现批量输入，http://blog.youkuaiyun.com/wangwo1991/article/details/52084287）这篇博客中写到了edittext的批量输入的实现，这篇博客里面是采用listview+edittext的方式实现的，比较容易实现，但是在处理edittext的焦点
android listview edittext 事件,Android ListView item中含有Edittext 中一些坑
weixin_36438028的博客
05-27 558
今天做一个界面. 是一个列表 .列表中有spinner,button,edittext等控件首次打开需要展示,用户可以修改,修改后数据保存.‍‍在保存Edittext控件上的值的时候,用的etRemark.addTextChangedListener(myTextWatcher)‍‍‍‍‍‍‍‍注意‍是addTextChangedListener来监听Edittext的值,如果变化的话 就将变...
实现Android ListView中EditText的批量录入与自定义键盘
Android ListView EditText批量录入功能，是指在Android平台上利用ListView组件和EditText组件来实现对数据的批量输入。ListView组件主要用于展示可滚动的列表项，而EditText组件则是一个文本输入框，用于获取用户的...
Android ListView用EditText实现搜索功能效果
08-31
"Android ListView使用EditText实现搜索功能效果" Android ListView是一个常用的UI组件，用于显示大量数据的列表视图。然而，在实际开发中，我们经常需要实现搜索功能，以便用户可以快速查找特定的数据项。在这篇...
Android ListView 用 EditText 实现搜索功能效果
06-14
本教程将详细讲解如何利用EditText来实现在ListView中的搜索功能。 首先，我们需要在布局文件中设置ListView和EditText。EditText作为搜索框，通常位于ListView上方，用户可以在此输入关键词进行搜索。布局可能如下...
ListView包含EditText处理
yinzhijiezhan的专栏
04-07 1021
一：重写ListView使其默认不可滑动。这样解决了条目中的EditText与键盘冲突的问题，冲突是指弹出键盘后EditText光标消失；关闭键盘后ListView默认是会刷新使你输入的内容又消失了。 二：用ScrollView包裹重写的NoScrollListView，使其获得滑动效果。 三：有多少个item，在adapter中就viewType就分多少泪。这样使得各个条目是独立的，方便af
android ListView实现多选，批量删除
06-07
可以多选批量删除的item的ListView，实现勾选的隐藏和显示
获得listview中的edittext文字
wode_dream的专栏
11-07 3243
这周写应用的时候遇到一个问题，就是在listview中的edittext可以输入，但不能获得到edittext中输入的文字。解决的方法是给edittext添加TextWatcher监听事件，并在其中让edittext在输入时通过调用dispatchKeyEvent()方法一直获得焦点，最后在setOnKeyListener()中获得edittext输入的文字。 示例代码如下（代码全部写在adap
学习笔记-Android之ListView随EditText输入内容动态改变
weixin_33795093的博客
09-12 243
2019独角兽企业重金招聘Python工程师标准>>> ...
android怎么获取edittext的值,android – 如何在ListView中获取所有EditText的值
weixin_31653131的博客
05-27 591
我想获取ListView中存在的所有EditText元素的所有值.这是我的代码：final ListView editorList = (ListView) findViewById(R.id.editorList);final EditorAdapter adapter = new EditorAdapter(context, data);editorList.setAdapter(adapte...
Android在Listview中使用EditText
xiaodongvtion的专栏
05-23 3015
服务器挂了，或许这个可以解决我的问题 这一段写一个小程序，有某个界面需要编辑较多的数据，于是用了一个Listview，将EditText放进去用来做编辑控件，遇到了下面的情况：  1.屏幕内容滚动时会调用ListView的Adapter的getView()重新产生View，这就要求及时保存EditText中的数据，不然会丢失，使用了Listener监听EditText的TextChange，但
安卓Android控件ListView获取item中EditText值
az44yao的专栏
06-19 9502
可以明确,现在没有直接方法可以获得ListView中每一行EditText的值.     解决方案:重写BaseAdapter,然后自行获取ListView中每行输入的EditText值.     大概算法:重写BaseAdapter.getView函数,用一个数组存储EditText中的值,根据position即数组下标,在getView中动态更新EditText和动态获取EditText中
android 获取ListView的Item中多个Edittext的输入值
迟到的微笑
06-15 3016
文章开始之前，请大家思考这样一个问题 ListView的每条Item中多个Edittext如何获取输入值？且防止数据错乱？ 如果是你你会怎么做？如果你有更好的思路欢迎你留言，谢谢 先给老铁们上一张动态图 这里我偷了一个懒，直接使用的是我的Android中ListView结合CheckBox获取选中项 博客中的源代码来实现的 可以看到我们的动态图上，单选，全选，局部修改...
Android中实现对多个EditText的输入监听
会飞的小驴粪蛋
05-16 6961
开发中，有时候会使用多个editText，获取到输入的内容，给一个EditText设置输入监听很简单，那么多个EditText呢？这里提供一种方法，可以快速搞定，上代码来…… @Override protected void initView(View view) { super.initView(view); TextChange textChange=new TextCh...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值