精华内容
下载资源
问答
  • 自定义android虚拟键盘

    2016-08-11 16:07:28
    自定义android虚拟键盘
  • Android 虚拟键盘

    2012-07-25 17:24:12
    Android开发:在EditText中关闭软键盘 转载 1、EditText有焦点(focusable为true)阻止输入法弹出 editText=(EditText)findViewById(R.id.txtBody); editText.setOnTouchListener(new OnTouchListener() { ...
    Android开发:在EditText中关闭软键盘
    转载
    1、EditText有焦点(focusable为true)阻止输入法弹出

    editText=(EditText)findViewById(R.id.txtBody);

    editText.setOnTouchListener(new OnTouchListener() {

    public boolean onTouch(View v, MotionEvent event) {

    editText.setInputType(InputType.TYPE_NULL); // 关闭软键盘

    return false;

    }

    });

    2、当EidtText无焦点(focusable=false)时阻止输入法弹出
    InputMethodManager imm = (InputMethodManager)getSystemService(INPUT_METHOD_SERVICE);

    imm.hideSoftInputFromWindow(editText.getWindowToken(), 0);
    展开全文
  • Delphi XE 开发Android虚拟键盘 ,源码文件:FMX.VirtualKeyboard.Android
  • Android虚拟键盘的弹起会遮挡住部分ui,虽然通过在清单文件中设置,可以随着虚拟键盘的弹出,布局往上推,但是面对登陆界面时,并没有太大的作用,这样就会导致用户体验不好;开发中既然出现了就的解决;先说先解决...
  • 通过ADB的Android虚拟键盘输入 ADBKeyBoard是一个虚拟键盘,可以接收来自系统广播意图的命令,您可以使用adb发送文本输入。 有一个shell命令“输入”,可以帮助您将文本输入发送到Android系统。 usage: input ...
  • android虚拟键盘判断和高度获取代码

    千次阅读 2017-04-13 14:05:21
    android虚拟键盘判断和高度获取代码


    /**
     * 判断底部navigator是否已经显示
     * @param windowManager
     * @return
     */
    @TargetApi(Build.VERSION_CODES.JELLY_BEAN_MR1)
    public static boolean hasSoftKeys(WindowManager windowManager){
        Display d = windowManager.getDefaultDisplay();
    
        DisplayMetrics realDisplayMetrics = new DisplayMetrics();
        d.getRealMetrics(realDisplayMetrics);
    
        int realHeight = realDisplayMetrics.heightPixels;
        int realWidth = realDisplayMetrics.widthPixels;
    
        DisplayMetrics displayMetrics = new DisplayMetrics();
        d.getMetrics(displayMetrics);
    
        int displayHeight = displayMetrics.heightPixels;
        int displayWidth = displayMetrics.widthPixels;
    
        return (realWidth - displayWidth) > 0 || (realHeight - displayHeight) > 0;
    }


        /**
         * 两个方法,第一个判断手机有没有开启虚拟键盘
         * 第二个方法获取虚拟键盘的高度
         */
        public static boolean checkDeviceHasNavigationBar(Context context) {
            boolean hasNavigationBar = false;
            Resources rs = context.getResources();
            int id = rs.getIdentifier("config_showNavigationBar", "bool", "android");
            if (id > 0) {
                hasNavigationBar = rs.getBoolean(id);
            }
            try {
                Class systemPropertiesClass = Class.forName("android.os.SystemProperties");
                Method m = systemPropertiesClass.getMethod("get", String.class);
                String navBarOverride = (String) m.invoke(systemPropertiesClass, "qemu.hw.mainkeys");
                if ("1".equals(navBarOverride)) {
                    hasNavigationBar = false;
                } else if ("0".equals(navBarOverride)) {
                    hasNavigationBar = true;
                }
            } catch (Exception e) {
            }
    
            return hasNavigationBar;
    
        }
    
        /**
        * 可以更具View的思想来计算出高度
        */
        public static int getNavigationBarHeight(Context context) {
            int navigationBarHeight = 0;
            Resources rs = context.getResources();
            int id = rs.getIdentifier("navigation_bar_height", "dimen", "android");
            if (id > 0 && checkDeviceHasNavigationBar(context)) {
                navigationBarHeight = rs.getDimensionPixelSize(id);
            }
            return navigationBarHeight;
        }

    具体的结构,要根据手机的情况来判断..上面的方法,在个别手机上,仍然是不通用的.


    经常,我们需要获得虚拟键盘的高度什么信息,都是应为输入,或者Web界面的情形...

    如果有键盘的话,在menifest的 Activity标签下修改 SoftInputAdjust 的值为自适应,也能解决很多问题.


    希望分享对你们有用.


    展开全文
  • android虚拟键盘的弹起会遮挡住部分ui,虽然通过在清单文件中设置,可以随着虚拟键盘的弹出,布局往上推,但是面对登陆界面时,并没有太大的作用,这样就会导致用户体验不好;开发中既然出现了就的解决;先说先解决...

    android虚拟键盘的弹起会遮挡住部分ui,虽然通过在清单文件中设置,可以随着虚拟键盘的弹出,布局往上推,但是面对登陆界面时,并没有太大的作用,这样就会导致用户体验不好;开发中既然出现了就的解决;先说先解决的思路:获取到屏幕的高度、虚拟键盘的高度,布局的高度,用屏幕的高度减去布局的高度,用高度差和虚拟键盘的高度进行对比;代码实现如下;

    private LinearLayout logo_layout;
        private ImageView iv_logo;
        private int sh;
        private int layoutH;
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
            logo_layout=(LinearLayout) findViewById(R.id.logo_layout);
            iv_logo=(ImageView) findViewById(R.id.iv_logo);
            //获取屏幕的高度
            DisplayMetrics dm = new DisplayMetrics();
            WindowManager windowMgr = (WindowManager)getSystemService(Context.WINDOW_SERVICE);
            windowMgr.getDefaultDisplay().getMetrics(dm);
            sh = dm.heightPixels;
            logo_layout.getViewTreeObserver().addOnGlobalLayoutListener(new OnGlobalLayoutListener() {
    
                // 当layout执行结束后回调此方法
                @Override
                public void onGlobalLayout() {
                    logo_layout.getViewTreeObserver().removeGlobalOnLayoutListener(this);
                    layoutH = logo_layout.getHeight();
                }
            });
            //当键盘弹起的时候用屏幕的高度减去布局的高度,同时获取到键盘的高度,用键盘的高度和剩余的高度做对比
            SoftKeyBoardListener.setListener(MainActivity.this, new OnSoftKeyBoardChangeListener() {
    
                @Override
                public void keyBoardShow(int height) {
                    //键盘弹起回调
                    int h=sh-layoutH;
                    if(h>height){//高度大于键盘的高度
                        setLayoutH(80);
                    }else{
                        //高度小于键盘的高度
                        int resetH=Math.abs(height+layoutH-sh);
                        setLayoutH(resetH);
                    }
                }
    
                @Override
                public void keyBoardHide(int height) {
                    //键盘隐藏回调
                    setLayoutH(80);
                }
            });     
        }
        /**
         * 重新设置布局高度
         */
        private void setLayoutH(int h){
            LinearLayout.LayoutParams layoutParams = (android.widget.LinearLayout.LayoutParams) iv_logo.getLayoutParams();
            layoutParams.topMargin=dip2px(MainActivity.this, h);
            iv_logo.setLayoutParams(layoutParams);
        }
        /** 
         * 根据手机的分辨率从 dp 的单位 转成为 px(像素) 
         */  
        public static int dip2px(Context context,float dpValue) {  
            final float scale =context.getResources().getDisplayMetrics().density;  
            return (int) (dpValue * scale + 0.5f);  
        }  
    private View rootView;//activity的根视图
        int rootViewVisibleHeight;//纪录根视图的显示高度
        private OnSoftKeyBoardChangeListener onSoftKeyBoardChangeListener;
    
        public SoftKeyBoardListener(Activity activity) {
            //获取activity的根视图
            rootView = activity.getWindow().getDecorView();
    
            //监听视图树中全局布局发生改变或者视图树中的某个视图的可视状态发生改变
            rootView.getViewTreeObserver().addOnGlobalLayoutListener(new ViewTreeObserver.OnGlobalLayoutListener() {
                @Override
                public void onGlobalLayout() {
                    //获取当前根视图在屏幕上显示的大小
                    Rect r = new Rect();
                    rootView.getWindowVisibleDisplayFrame(r);
                    int visibleHeight = r.height();
                    if (rootViewVisibleHeight == 0) {
                        rootViewVisibleHeight = visibleHeight;
                        return;
                    }
    
                    //根视图显示高度没有变化,可以看作软键盘显示/隐藏状态没有改变
                    if (rootViewVisibleHeight == visibleHeight) {
                        return;
                    }
    
                    //根视图显示高度变小超过200,可以看作软键盘显示了
                    if (rootViewVisibleHeight - visibleHeight > 200) {
                        if (onSoftKeyBoardChangeListener != null) {
                            onSoftKeyBoardChangeListener.keyBoardShow(rootViewVisibleHeight - visibleHeight);
                        }
                        rootViewVisibleHeight = visibleHeight;
                        return;
                    }
    
                    //根视图显示高度变大超过200,可以看作软键盘隐藏了
                    if (visibleHeight - rootViewVisibleHeight > 200) {
                        if (onSoftKeyBoardChangeListener != null) {
                            onSoftKeyBoardChangeListener.keyBoardHide(visibleHeight - rootViewVisibleHeight);
                        }
                        rootViewVisibleHeight = visibleHeight;
                        return;
                    }
    
                }
            });
        }
    
        private void setOnSoftKeyBoardChangeListener(OnSoftKeyBoardChangeListener onSoftKeyBoardChangeListener) {
            this.onSoftKeyBoardChangeListener = onSoftKeyBoardChangeListener;
        }
    
        public interface OnSoftKeyBoardChangeListener {
            void keyBoardShow(int height);
    
            void keyBoardHide(int height);
        }
    
        public static void setListener(Activity activity, OnSoftKeyBoardChangeListener onSoftKeyBoardChangeListener) {
            SoftKeyBoardListener softKeyBoardListener = new SoftKeyBoardListener(activity);
            softKeyBoardListener.setOnSoftKeyBoardChangeListener(onSoftKeyBoardChangeListener);
        }

    以上做了仔细说明了,运行效果如下:
    这里写图片描述
    源码:http://download.csdn.net/detail/wangwo1991/9746729

    展开全文
  • android虚拟键盘实现

    2015-04-30 12:12:12
    生成虚拟键盘的DIALOG方法: package org.socketclient.keyboard; import org.socketclient.R; import android.app.AlertDialog; import android.content.Context; import android.os.Message; import ...

    生成虚拟键盘的DIALOG方法:

    package org.socketclient.keyboard;

    import org.socketclient.R;
    import android.app.AlertDialog;
    import android.content.Context;
    import android.os.Message;
    import android.view.MotionEvent;
    import android.view.View;
    import android.view.View.OnTouchListener;

    public class KeyBoardDialog{

        public Context context;

        public VirtualKeyboard keybord;
        
        public MessageHandler messageHandler;
        
        public KeyBoardDialog(Context context,MessageHandler handler){
            this.context = context;
            this.messageHandler = handler;
        }

        public AlertDialog CreateDialog(){
            AlertDialog localAlertDialog = new AlertDialog.Builder(context).create();
            localAlertDialog.show();
            localAlertDialog.setContentView(R.layout.virtual_keyboard_layout);
            localAlertDialog.setCanceledOnTouchOutside(false);
            keybord = (VirtualKeyboard) localAlertDialog.findViewById(R.id.virtualKeyboard1);
            keybord.setOnTouchListener(listener);
            return localAlertDialog;
        }
        //当前坐标点位置
        int cx = 0,cy = 0;
        final OnTouchListener listener = new OnTouchListener() {
            @Override
            public boolean onTouch(View view, MotionEvent event) {
                // TODO Auto-generated method stub
                cx = (int) event.getX();
                cy = (int) event.getY();
                switch (event.getAction()) {
                case MotionEvent.ACTION_DOWN:
                    keybord.postInvalidate(cx, cy, 0, 0);
                    if(keybord.currentModel != null){
                        Message message = new Message();
                        message.what = 1001;
                        message.obj = keybord.currentModel.code;
                        messageHandler.handler.sendMessage(message);
                    }
                    break;
                case MotionEvent.ACTION_MOVE:
                    break;
                case MotionEvent.ACTION_UP:
                    break;
                }
                return false;
            }
        };
    }

    消息相应类:

    package org.socketclient.keyboard;

    import android.annotation.SuppressLint;
    import android.os.Handler;
    import android.os.Message;

    public abstract class MessageHandler {

        public Handler handler;
        
        public MessageHandler(){
            createHandler();
        }
        
        @SuppressLint("HandlerLeak")
        public void createHandler(){
            handler = new Handler(){
                @Override
                public void handleMessage(Message msg) {
                    // TODO Auto-generated method stub
                    if(msg.what == 1001){
                        onTouchMessage(String.valueOf((Integer)msg.obj));
                    }
                    super.handleMessage(msg);
                }
            };
        }
        
        public abstract void onTouchMessage(String message);
    }




    自定义虚拟键盘控件

    package org.socketclient.keyboard;

    import java.util.ArrayList;
    import org.socketclient.R;
    import android.annotation.SuppressLint;
    import android.content.Context;
    import android.graphics.Bitmap;
    import android.graphics.BitmapFactory;
    import android.graphics.Canvas;
    import android.graphics.Color;
    import android.graphics.Matrix;
    import android.graphics.Paint;
    import android.graphics.Rect;
    import android.graphics.RectF;
    import android.util.AttributeSet;
    import android.view.View;

    @SuppressLint("DrawAllocation")
    public class VirtualKeyboard extends View {

        public int width;

        public int height;

        public int keyWidth;

        public int keyHeight;

        public final int rows = 6;

        public final int cols = 10;

        public final Rect brect = new Rect(0,0,100,100);

        public Paint paint;

        public boolean isfirst = true;
        //代表当前的按钮所代表的按键
        public int[][] keyText = {
                {0x11,0x12,0x20,0x0D,0x28,0x26,0x25,0x27},
                {0x10,0x4C,0x5A,0x58,0x43,0x56,0x42,0x4E,0x4D,0x08},
                {0x1B,0x41,0x53,0x44,0x46,0x47,0x48,0x4A,0x4B,0x2E},
                {0x51,0x57,0x45,0x52,0x54,0x59,0x55,0x49,0x4F,0x50},
                {0x31,0x32,0x33,0x34,0x35,0x36,0x37,0x38,0x39,0x30}};
        //当前按钮所代表的图标
        public int[][] keyBitmapId = {
                {R.drawable.ctrl,R.drawable.alt,R.drawable.space,R.drawable.enter,R.drawable.down,R.drawable.up,R.drawable.left,R.drawable.right},
                {R.drawable.shift,R.drawable.l,R.drawable.z,R.drawable.x,R.drawable.c,R.drawable.v,R.drawable.b,R.drawable.n,R.drawable.m,R.drawable.bspace},
                {R.drawable.esc,R.drawable.a,R.drawable.s,R.drawable.d,R.drawable.f,R.drawable.g,R.drawable.h,R.drawable.j,R.drawable.k,R.drawable.delete},
                {R.drawable.q,R.drawable.w,R.drawable.e,R.drawable.r,R.drawable.t,R.drawable.y,R.drawable.u,R.drawable.i,R.drawable.o,R.drawable.p},
                {R.drawable.n1,R.drawable.n2,R.drawable.n3,R.drawable.n4,R.drawable.n5,R.drawable.n6,R.drawable.n7,R.drawable.n8,R.drawable.n9,R.drawable.n0}};
        //被按下按钮所代表图标
        public int[][] keyBitmapId2 = {
                {R.drawable.ctrl1,R.drawable.alt1,R.drawable.space1,R.drawable.enter1,R.drawable.down1,R.drawable.up1,R.drawable.left1,R.drawable.right1},
                {R.drawable.shift1,R.drawable.l1,R.drawable.z1,R.drawable.x1,R.drawable.c1,R.drawable.v1,R.drawable.b1,R.drawable.nn1,R.drawable.m1,R.drawable.bspace1},
                {R.drawable.esc1,R.drawable.a1,R.drawable.s1,R.drawable.d1,R.drawable.f1,R.drawable.g1,R.drawable.h1,R.drawable.j1,R.drawable.k1,R.drawable.delete1},
                {R.drawable.q1,R.drawable.w1,R.drawable.e1,R.drawable.r1,R.drawable.t1,R.drawable.y1,R.drawable.u1,R.drawable.i1,R.drawable.o1,R.drawable.p1},
                {R.drawable.n11,R.drawable.n22,R.drawable.n33,R.drawable.n44,R.drawable.n55,R.drawable.n66,R.drawable.n77,R.drawable.n88,R.drawable.n99,R.drawable.n00}};

        //按钮集合
        public ArrayList<KeyModel> keylist = null;
        //当前被按下按钮
        public KeyModel currentModel = null;

        public VirtualKeyboard(Context context) {
            super(context);
            // TODO Auto-generated constructor stub
            init();
        }

        public VirtualKeyboard(Context context, AttributeSet attrs) {
            super(context, attrs);
            // TODO Auto-generated constructor stub
            init();
        }

        public VirtualKeyboard(Context context, AttributeSet attrs, int defStyle) {
            super(context, attrs, defStyle);
            // TODO Auto-generated constructor stub
            init();
        }
        //初始化按钮
        public void init(){
            paint = new Paint(Paint.ANTI_ALIAS_FLAG);
            paint = new Paint(Paint.ANTI_ALIAS_FLAG);
            paint.setStyle(Paint.Style.FILL);
            paint.setColor(Color.WHITE); // 红色圆形

            if(keylist != null)
                keylist.clear();
            keylist = new ArrayList<KeyModel>();
            //获取布局大小
            int width = getWidth();
            int height = getHeight();
            //计算单个按钮大小
            keyWidth = width / rows;
            keyHeight = height / cols;
            for(int i=0; i<keyBitmapId.length; i++){
                for(int j=0; j<keyBitmapId[i].length; j++){
                    KeyModel model;
                    if(i == 0){
                        if(j < 2){
                            model = new KeyModel(i * keyWidth,
                                    j * keyHeight,(i + 1) * keyWidth,(j+1) * keyHeight);
                        }else if(j == 2){
                            model = new KeyModel(i * keyWidth,
                                    j * keyHeight,(i + 1) * keyWidth,(j + 2) * keyHeight);
                        }else if(j == 3){
                            model = new KeyModel(i * keyWidth,
                                    (j + 1) * keyHeight,(i + 1) * keyWidth,(j + 3) * keyHeight);
                        }else{
                            model = new KeyModel(i * keyWidth,
                                    (j + 2) * keyHeight,(i + 1) * keyWidth,(j + 3) * keyHeight);
                        }
                    }else{
                        model = new KeyModel(i * keyWidth,
                                j * keyHeight,(i + 1) * keyWidth,(j+1) * keyHeight);
                    }
                    //显示编号
                    model.index = i;
                    model.jndex = j;
                    model.bitmap = BitmapFactory.decodeResource(getResources(), keyBitmapId[i][j]);
                    model.code = keyText[i][j];
                    keylist.add(model);
                }
            }
        }
        //绘制键盘
        @SuppressLint("DrawAllocation")
        @Override
        protected void onDraw(Canvas canvas) {
            // TODO Auto-generated method stub
            super.onDraw(canvas);
            //绘制  
            if(isfirst == true){
                init();
            }
            isfirst = false;
            //  设置背景色
            paint.setColor(Color.BLACK);
            for(int i=0; i<keylist.size(); i++){
                KeyModel model = keylist.get(i);
                RectF rectf = model.textf;
                Matrix matrix = new Matrix();  
                // 缩放原图  
                matrix.postScale(1f, 1f);  
                // 向左旋转45度,参数为正则向右旋转  
                matrix.postRotate(90);  
                //bmp.getWidth(), 500分别表示重绘后的位图宽高  
                Bitmap dstbmp = Bitmap.createBitmap(model.bitmap, 0, 0, 100, 100,  
                        matrix, true);
                canvas.drawBitmap(dstbmp, brect, rectf, paint);
            }

            if(currentModel != null){
                Matrix matrix = new Matrix();  
                // 缩放原图  
                matrix.postScale(1f, 1f);  
                // 向左旋转45度,参数为正则向右旋转  
                matrix.postRotate(90);  
                //bmp.getWidth(), 500分别表示重绘后的位图宽高  
                Bitmap bitmap = BitmapFactory.decodeResource(getResources(), keyBitmapId2[currentModel.index][currentModel.jndex]);
                Bitmap dstbmp = Bitmap.createBitmap(bitmap, 0, 0, 100, 100,  
                        matrix, true);
                canvas.drawBitmap(dstbmp, brect, currentModel.textf, paint);
            }
            System.out.println("绘制图像了吗?");
        }
        //重新绘制键盘
        @Override
        public void postInvalidate(int left, int top, int right, int bottom) {
            // TODO Auto-generated method stub
            currentModel = null;
            GetClickKey(left,top);
            if(currentModel != null){
                super.postInvalidate((int)currentModel.textf.left,(int)currentModel.textf.top,
                        (int)currentModel.textf.right,(int)currentModel.textf.bottom);
            }
            else{
                super.postInvalidate(0,0,0,0);
            }
        }
        //计算当前本按下键盘位置
        public void GetClickKey(int left, int top){
            int index = left / keyWidth;
            int jndex = top / keyHeight;
            //第一行特殊处理数据
            if(index == 0){
                if(jndex == 3)
                    jndex = 2;
                if(jndex == 4 || jndex == 5)
                    jndex = 3;
                if(jndex > 5)
                    jndex = jndex - 2;
            }
            for(int i=0; i<keylist.size(); i++){
                KeyModel model = keylist.get(i);
                if(model.index == index && model.jndex == jndex){
                    currentModel = model;
                }
            }
        }
        //按键类
        class KeyModel{
            public KeyModel(int x,int y,int x1,int y1){
                textf = new RectF(x,y,x1,y1);
            }
            //左下角位置
            public RectF textf;
            //显示图片
            public Bitmap bitmap;
            //代表的字符串
            public int code;
            //显示编号
            public int index;
            public int jndex;
        }

    }

    调用方法:

    KeyBoardDialog dialog = new KeyBoardDialog(BaseActivity1.this , new MessageHandler() {
                @Override
                public void onTouchMessage(String message) {
                    // TODO Auto-generated method stub
                    sendMessage("b,"+message,"Contrl",-1);
                }
            });
            dialog.CreateDialog();





    展开全文
  • 移动开发跟虚拟键盘肯定要打交道,下来我们就说说常用的相关情况: 情况一、将键盘右下角的确认更改 android:imeOptions="actionDone",软键盘下方变成“完成”, android:imeOptions="actionSend",软键盘下方...
  • InputMethodService为我们的输入法创建了一个Dialog,并且对某些参数进行了设置,使之能够在底部或者全屏显示。...: 软键盘的状态(隐藏或可见)没有被指定。系统将选择一个合适的状态或依赖于主题的设置...
  • 系统本身没有提供获取虚拟键盘的方法,在网上查了一些资料,发现还存在一点问题,故此把改好的代码记录下来,以备后用。 需要用OnGlobalLayoutListener来监听app窗口的变化 final View decorView = getActivity()....
  • 1: android:fitsSystemWindows=...2:监听虚拟键盘的变化 在主activity的oncreate中调用 Workaround.assistActivity(findViewById(android.R.id.content)); // Workaround 类的方法  package com.qianyue.g
  • 我想在默认的英文虚拟键盘中增加一个 字符(印度货币符号),在网上有看到关于【怎么在android虚拟键盘增加一个自定义的键呢?】 的文章 ,但是并不会显示到虚拟键盘上, 不知道哪里是修改 虚拟键盘布局的地方,请...
  • android 虚拟键盘控制

    2013-07-12 13:00:00
    键盘显示的原理 软键盘的本质是什么?软键盘其实是一个Dialog! InputMethodService为我们的输入法创建了一个Dialog,并且将该Dialog的Window的某些参数(如Gravity)进行了设置,使之能够在底部或者全屏显示...
  • :软键盘的状态(隐藏或可见)没有被指定。系统将选择一个合适的状态或依赖于主题的设置。这个是软件盘行为的默认设置。 "stateUnchanged":软键盘被保持上次的状态。 "stateHid...
  • android 虚拟键盘的显示与隐藏问题

    千次阅读 2015-06-29 21:16:33
    焦点改变时如何隐藏虚拟键盘 在开发过程中碰到了一个需求:在点击搜索框后,再点击别的地方,让虚拟键盘隐藏 在焦点改变时,隐藏虚拟键盘。在 listView 中添加焦点监听。其中 mEditText 为所输入的文本...
  • 1.虚拟键盘的坑  一般情况下,如果虚拟键盘弹不起底部的输入框,就直接在Manifest对应的Activity中配置一把, android:windowSoftInputMode="adjustPan" 然而在我的工程中并没有什么卵用,然后还是google大神帮我...
  • Android使用 input 输入文本时,不期望出现虚拟键盘; 一般情况下,大家会把键盘给卸载,不过也有简单的方法: 就是下载一个 com.wparam.nullkeyboard (NullKeyboard); 在使用input命令前,把它设置成默认...
  • Android soft keyboard overlap with input div on browser 【Android虚拟键盘与输入框重叠】 给个英文标题,因为我知道绝大部分人搜资料都用英文搜。 问题: 在Android设备浏览器上打开自己的页面,当点击页面...
  • android 虚拟键盘遮挡布局 顶起布局

    千次阅读 2019-02-23 10:51:06
    android 的 XML 中设置 fitsSystemWindows 属性的分析: fitsSystemWindows 只作用在 sdk&gt;=19 的系统上就是高于 4.4 的系统 android:fitsSystemWindows="true" 这个属性可以给任何 view 设置,...
  • 1>软键盘的状态——隐藏或显示。 一:自动弹出软键盘Timer timer=new Timer();  timer.schedule(new TimerTask() { public void run() { InputMethodManager inputMethodManag

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 913
精华内容 365
关键字:

android虚拟键盘