ADROID 2.1 架构解析 7 键盘

Android输入事件从读取到分发二:谁在循环监听事件的到来 通过上一节初步阅读代码,已经找到了读写/dev/input/设备文件节点的位置。但是最后,我觉得应该有一个线程,一直循环监听这些输入设备,有事件的时候就去处理,没有事件的时候就睡眠,等待事件的到来。那么,这部分的代码是怎么样的呢? 上一节只是为了定位android系统在什么地方监听输入设备,所以很多地方没有仔细分析,这一节,带着文章开头提出的问题,再一次分析源码,而我们的入口,任然是系统启动后, 阅读详情

7 键盘

系统在KeyInputQueue服务里创建了一个线程,在这个线程里不断读取输入事件,然后对这个事件进行处理。

7.1 按键输入队列服务

按键输入事件有多种方式,如:键盘敲击、触摸屏触击、鼠标点击及多点触摸,主要是按下和放开的事件。

7.1.1 输入事件的数据结构

文件:frameworks/base/core/java/android/view/RawInputEvent.java

public class RawInputEvent {

    // Event class as defined by EventHub.

    ...

    public int deviceId;

    public int type;

    public int scancode;

    public int keycode;

    public int flags;

    public int value;

    public long when;

}

7.1.2 输入事件服务

文件:frameworks/base/services/java/com/android/server/KeyInputQueue.java

7.1.2.1 获取事件

Thread mThread = new Thread("InputDeviceReader") {

        public void run() {

            if (DEBUG) Log.v(TAG, "InputDeviceReader.run()");

            android.os.Process.setThreadPriority(

                    android.os.Process.THREAD_PRIORITY_URGENT_DISPLAY);

        

            RawInputEvent ev = new RawInputEvent();

            while (true) {

                try {                  

                                   ...

                    // block, doesn't release the monitor

                    readEvent(ev);

                                   ...

调用readEvent,将输入事件读取到ev类,即RawInputEvent的变量里,readEvent对应jni的android_server_KeyInputQueue_readEvent

7.1.2.2 处理键盘事件

              ...

              public static KeyEvent newKeyEvent(InputDevice device, long downTime,

            long eventTime, boolean down, int keycode, int repeatCount,

            int scancode, int flags) {

        return new KeyEvent(

                downTime, eventTime,

                down ? KeyEvent.ACTION_DOWN : KeyEvent.ACTION_UP,

                keycode, repeatCount,

                device != null ? device.mMetaKeysState : 0,

                device != null ? device.id : -1, scancode,

                flags | KeyEvent.FLAG_FROM_SYSTEM);

}

Thread mThread = new Thread("InputDeviceReader") {

        public void run() {

            if (DEBUG) Log.v(TAG, "InputDeviceReader.run()");

            android.os.Process.setThreadPriority(

                    android.os.Process.THREAD_PRIORITY_URGENT_DISPLAY);

           

            RawInputEvent ev = new RawInputEvent();

            while (true) {

                try {

                    InputDevice di;

 

                    // block, doesn't release the monitor

                    readEvent(ev);

              ...

 

              final int scancode = ev.scancode;

              if (type == RawInputEvent.EV_KEY &&

                                (classes&RawInputEvent.CLASS_KEYBOARD) != 0 &&

                                (scancode < RawInputEvent.BTN_FIRST ||

                                        scancode > RawInputEvent.BTN_LAST)) {

                            boolean down;

                            if (ev.value != 0) {

                                down = true;

                                di.mKeyDownTime = curTime;

                            } else {

                                down = false;

                            }

                            int keycode = rotateKeyCodeLocked(ev.keycode);

                            addLocked(di, curTimeNano, ev.flags,

                                    RawInputEvent.CLASS_KEYBOARD,

                                    newKeyEvent(di, di.mKeyDownTime, curTime, down,

                                            keycode, 0, scancode,

                                            ((ev.flags & WindowManagerPolicy.FLAG_WOKE_HERE) != 0)

                                             ? KeyEvent.FLAG_WOKE_HERE : 0));

                           

                        }

处理键盘事件,并将该事件加入事件队列。

7.2硬件调用

文件:frameworks/base/services/jni/com_android_server_KeyInputQueue.cpp

int register_android_server_KeyInputQueue(JNIEnv* env)

{

    ...

    jclass inputEvent = env->FindClass("android/view/RawInputEvent");

    gInputOffsets.mDeviceId

        = env->GetFieldID(inputEvent, "deviceId", "I");

    gInputOffsets.mType

        = env->GetFieldID(inputEvent, "type", "I");

    gInputOffsets.mScancode

        = env->GetFieldID(inputEvent, "scancode", "I");

    gInputOffsets.mKeycode

        = env->GetFieldID(inputEvent, "keycode", "I");

    gInputOffsets.mFlags

        = env->GetFieldID(inputEvent, "flags", "I");

    gInputOffsets.mValue

        = env->GetFieldID(inputEvent, "value", "I");

    gInputOffsets.mWhen

        = env->GetFieldID(inputEvent, "when", "J");

    ...

}

获取android/view/RawInputEvent类的变量。

 

static jboolean

android_server_KeyInputQueue_readEvent(JNIEnv* env, jobject clazz,

                                          jobject event)

{

    gLock.lock();

    sp<EventHub> hub = gHub;

    if (hub == NULL) {

        hub = new EventHub;

        gHub = hub;

    }

    gLock.unlock();

 

    int32_t deviceId;

    int32_t type;

    int32_t scancode, keycode;

    uint32_t flags;

    int32_t value;

    nsecs_t when;

    bool res = hub->getEvent(&deviceId, &type, &scancode, &keycode,

            &flags, &value, &when);

 

    env->SetIntField(event, gInputOffsets.mDeviceId, (jint)deviceId);

    env->SetIntField(event, gInputOffsets.mType, (jint)type);

    env->SetIntField(event, gInputOffsets.mScancode, (jint)scancode);

    env->SetIntField(event, gInputOffsets.mKeycode, (jint)keycode);

    env->SetIntField(event, gInputOffsets.mFlags, (jint)flags);

    env->SetIntField(event, gInputOffsets.mValue, value);

    env->SetLongField(event, gInputOffsets.mWhen,

                        (jlong)(nanoseconds_to_milliseconds(when)));

 

    return res;

}

将从eventhub读到的变量存到android/view/RawInputEvent类对应的变量里。

7.3 EventHub库

文件:frameworks/base/libs/ui/EventHub.cpp

7.3.1 读取输入设备状态

static const char *device_path = "/dev/input";

bool EventHub::getEvent(int32_t* outDeviceId, int32_t* outType,

        int32_t* outScancode, int32_t* outKeycode, uint32_t *outFlags,

        int32_t* outValue, nsecs_t* outWhen)

{   

       ...

    if (!mOpened) {

        mError = openPlatformInput() ? NO_ERROR : UNKNOWN_ERROR;

        mOpened = true;

    }

       ...

    while(1) {

 

        pollres = poll(mFDs, mFDCount, -1);

 

        // mFDs[0] is used for inotify, so process regular events starting at mFDs[1]

        for(i = 1; i < mFDCount; i++) {

            if(mFDs[i].revents) {

                LOGV("revents for %d = 0x%08x", i, mFDs[i].revents);

                if(mFDs[i].revents & POLLIN) {

                    res = read(mFDs[i].fd, &iev, sizeof(iev));

                    if (res == sizeof(iev)) {

                        *outDeviceId = mDevices[i]->id;

                        if (*outDeviceId == mFirstKeyboardId) *outDeviceId = 0;

                        *outType = iev.type;

                        *outScancode = iev.code;

                        if (iev.type == EV_KEY) {

                            err = mDevices[i]->layoutMap->map(iev.code, outKeycode, outFlags);

                            if (err != 0) {

                                *outKeycode = 0;

                                *outFlags = 0;

                            }

                        } else {

                            *outKeycode = iev.code;

                        }

                        *outValue = iev.value;

                        *outWhen = s2ns(iev.time.tv_sec) + us2ns(iev.time.tv_usec);

                        return true;

                    } else {

                        if (res<0) {

                            LOGW("could not get event (errno=%d)", errno);

                        } else {

                            LOGE("could not get event (wrong size: %d)", res);

                        }

                        continue;

                    }

                }

            }

        }

       

        // read_notify() will modify mFDs and mFDCount, so this must be done after

        // processing all other events.

        if(mFDs[0].revents & POLLIN) {

            read_notify(mFDs[0].fd);

        }

    }

}

openPlatformInput() 打开/dev/input/ 目录下的所有输入设备文件。

打开设备后,不断轮循所有设备,直到读取有POLLIN事件产生的设备的状态。

7.3.2 导入键盘配置文件

int EventHub::open_device(const char *deviceName)

{

       ...

       if(ioctl(fd, EVIOCGNAME(sizeof(name) - 1), &name) < 1) {

        //fprintf(stderr, "could not get device name for %s, %s/n", deviceName, strerror(errno));

        name[0] = '/0';

    }

       ...

if ((device->classes&CLASS_KEYBOARD) != 0) {

        char tmpfn[sizeof(name)];

        char keylayoutFilename[300];

 

        // a more descriptive name

        device->name = name;

 

        // replace all the spaces with underscores

        strcpy(tmpfn, name);

        for (char *p = strchr(tmpfn, ' '); p && *p; p = strchr(tmpfn, ' '))

            *p = '_';

 

        // find the .kl file we need for this device

        const char* root = getenv("ANDROID_ROOT");

        snprintf(keylayoutFilename, sizeof(keylayoutFilename),

                 "%s/usr/keylayout/%s.kl", root, tmpfn);

        bool defaultKeymap = false;

        if (access(keylayoutFilename, R_OK)) {

            snprintf(keylayoutFilename, sizeof(keylayoutFilename),

                     "%s/usr/keylayout/%s", root, "qwerty.kl");

            defaultKeymap = true;

        }

        device->layoutMap->load(keylayoutFilename);

 

        // tell the world about the devname (the descriptive name)

        int32_t publicID;

        if (!mHaveFirstKeyboard && !defaultKeymap) {

            publicID = 0;

            // the built-in keyboard has a well-known device ID of 0,

            // this device better not go away.

            mHaveFirstKeyboard = true;

            mFirstKeyboardId = device->id;

        } else {

            publicID = device->id;

            // ensure mFirstKeyboardId is set to -something-.

            if (mFirstKeyboardId == 0) {

                mFirstKeyboardId = device->id;

            }

        }

        char propName[100];

        sprintf(propName, "hw.keyboards.%u.devname", publicID);

        property_set(propName, name);

 

        // 'Q' key support = cheap test of whether this is an alpha-capable kbd

        if (hasKeycode(device, kKeyCodeQ)) {

            device->classes |= CLASS_ALPHAKEY;

        }

       

        // See if this has a DPAD.

        if (hasKeycode(device, kKeyCodeDpadUp) &&

                hasKeycode(device, kKeyCodeDpadDown) &&

                hasKeycode(device, kKeyCodeDpadLeft) &&

                hasKeycode(device, kKeyCodeDpadRight) &&

                hasKeycode(device, kKeyCodeDpadCenter)) {

            device->classes |= CLASS_DPAD;

        }

       

        LOGI("New keyboard: publicID=%d device->id=0x%x devname='%s' propName='%s' keylayout='%s'/n",

                publicID, device->id, name, propName, keylayoutFilename);

    }

       ...

}

由以上代码可知,会优先加载/system/usr/keylayout/输入设备名称.kl

如: /sys/class/input/input1/name = keypad,则会加载/system/usr/keylayout/keypad.kl,如果该文件不存在,则加载默认文件/system/usr/keylayout/qwerty.kl,该文件的原型在:sdk/emulator/keymaps/qwerty.kl ,eclair以前的版本都是放在development/ emulator/keymaps/qwerty.kl

7.3.3 按键映射

如7.3.2所示代码,先加载配置文件:

device->layoutMap->load(keylayoutFilename);

如7.3.1所示代码,再将读取到的按键码进行转换:

err = mDevices[i]->layoutMap->map(iev.code, outKeycode, outFlags);

文件:frameworks/base/libs/ui/KeyLayoutMap.cpp

status_t

KeyLayoutMap::load(const char* filename)

{

int fd = open(filename, O_RDONLY);

...

while (true) {

        String8 token = next_token(&p, &line);

        if (*p == '/0') {

            break;

        }

        switch (state)

        {

            case BEGIN:

                if (token == "key") {

                    state = SCANCODE;

                } else {

                    LOGE("%s:%d: expected key, got '%s'/n", filename, line,

                            token.string());

                    err = BAD_VALUE;

                    goto done;

                }

                break;

            case SCANCODE:

                scancode = strtol(token.string(), &end, 0);

                if (*end != '/0') {

                    LOGE("%s:%d: expected scancode (a number), got '%s'/n",

                            filename, line, token.string());

                    goto done;

                }

                //LOGI("%s:%d: got scancode %d/n", filename, line, scancode );

                state = KEYCODE;

                break;

            case KEYCODE:

                keycode = token_to_value(token.string(), KEYCODES);

                //LOGI("%s:%d: got keycode %d for %s/n", filename, line, keycode, token.string() );

                if (keycode == 0) {

                    LOGE("%s:%d: expected keycode, got '%s'/n",

                            filename, line, token.string());

                    goto done;

                }

                state = FLAG;

                break;

            case FLAG:

                if (token == "key") {

                    if (scancode != -1) {

                        //LOGI("got key decl scancode=%d keycode=%d"

                        //       " flags=0x%08x/n", scancode, keycode, flags);

                        Key k = { keycode, flags };

                        m_keys.add(scancode, k);

                        state = SCANCODE;

                        scancode = -1;

                        keycode = -1;

                        flags = 0;

                        break;

                    }

                }

                tmp = token_to_value(token.string(), FLAGS);

                //LOGI("%s:%d: got flags %x for %s/n", filename, line, tmp, token.string() );

                if (tmp == 0) {

                    LOGE("%s:%d: expected flag, got '%s'/n",

                            filename, line, token.string());

                    goto done;

                }

                flags |= tmp;

                break;

        }

    }

...

}

由以上代码可知,是以如下方式对配置文件进行解析的:

BEGIN: 如果第一个关键字是key,则转入SCANCODE,否则退出。

SCANCODE: 将第二个关键字转为数字,即扫描码scancode,转向KEYCODE。

KEYCODE: 将第三个关键字与KEYCODES列表配对,找出关键码keycode,转向FLAG。

FLAG:如果第四个关键字是key,则保存刚扫描的键码,然后转向SCANCODE,否则将该关键字与FLAGS列表配对,找出flags值,然后转向BEGIN。

 

注:KEYCODES列表和FLAGS列表的定义在:

frameworks/base/include/ui/KeycodeLabels.h

 

status_t

KeyLayoutMap::map(int32_t scancode, int32_t *keycode, uint32_t *flags) const

{

    if (m_status != NO_ERROR) {

        return m_status;

    }

 

    ssize_t index = m_keys.indexOfKey(scancode);

    if (index < 0) {

        //LOGW("couldn't map scancode=%d/n", scancode);

        return NAME_NOT_FOUND;

    }

 

    const Key& k = m_keys.valueAt(index);

 

    *keycode = k.keycode;

    *flags = k.flags;

 

    //LOGD("mapped scancode=%d to keycode=%d flags=0x%08x/n", scancode,

    //        keycode, flags);

 

    return NO_ERROR;

}

Map的功能是根据scancode,找到对应的keycode.

 

qwerty.kl 的部分配置:

#  scancode    keycode      flags

key 399   GRAVE

key 2     1

key 3     2

key 4     3

key 5     4

key 6     5

key 7     6

key 8     7

key 9     8

key 10    9

key 11    0

key 158   BACK              WAKE_DROPPED

key 230   SOFT_RIGHT        WAKE

key 60    SOFT_RIGHT        WAKE

 

7.4 字符映射

7.4.1 加载字符配置表

文件:frameworks/base/core/java/android/view/KeyCharacterMap.java
public static KeyCharacterMap load(int keyboard)

{

       ...

            result = new KeyCharacterMap(keyboard);

              ...

     }

private KeyCharacterMap(int keyboardDevice)

    {

        mKeyboardDevice = keyboardDevice;

        mPointer = ctor_native(keyboardDevice);

    }

ctor_native 原型如下:

文件:frameworks/base/core/jni/android_text_KeyCharacterMap.cpp

static JNINativeMethod g_methods[] = {

    /* name, signature, funcPtr */

{ "ctor_native",             "(I)I",    (void*)ctor },

...

};

static jint

ctor(JNIEnv *env, jobject clazz, jint id)

{

    return reinterpret_cast<int>(KeyCharacterMap::load(id));

}

KeyCharacterMap::load原型如下:

文件:frameworks/base/libs/ui/KeyCharacterMap.cpp

KeyCharacterMap*

KeyCharacterMap::load(int id)

{

    KeyCharacterMap* rv = NULL;

    char path[PATH_MAX];

    char propName[100];

    char dev[PROPERTY_VALUE_MAX];

    char tmpfn[PROPERTY_VALUE_MAX];

    int err;

    const char* root = getenv("ANDROID_ROOT");

 

    sprintf(propName, "hw.keyboards.%u.devname", id);

    err = property_get(propName, dev, "");

    if (err > 0) {

        // replace all the spaces with underscores

        strcpy(tmpfn, dev);

        for (char *p = strchr(tmpfn, ' '); p && *p; p = strchr(tmpfn, ' '))

            *p = '_';

        snprintf(path, sizeof(path), "%s/usr/keychars/%s.kcm.bin", root, tmpfn);

        //LOGD("load: dev='%s' path='%s'/n", dev, path);

        rv = try_file(path);

        if (rv != NULL) {

            return rv;

        }

        LOGW("Error loading keycharmap file '%s'. %s='%s'", path, propName, dev);

    } else {

        LOGW("No keyboard for id %d", id);

    }

 

    snprintf(path, sizeof(path), "%s/usr/keychars/qwerty.kcm.bin", root);

    rv = try_file(path);

    if (rv == NULL) {

        LOGE("Can't find any keycharmaps (also tried %s)", path);

        return NULL;

    }

    LOGW("Using default keymap: %s", path);

 

    return rv;

}

以上所提及代码要实现的功能是:先查看hw.keyboards.%u.devname的属性,若存在则打开/system/usr/keychars/%s.kcm.bin文件,否则打开默认文件:/system/usr/keychars/qwerty.kcm.bin

 

文件:frameworks/base/libs/ui/EventHub.cpp

参考<<7.3.2 导入键盘配置文件>>里的:

char propName[100];

        sprintf(propName, "hw.keyboards.%u.devname", publicID);

        property_set(propName, name);

在代码里设置了KeyCharacterMap::load 中hw.keyboards.%u.devname所需要的值,即设备名称,如: /sys/class/input/input1/name = keypad,则会加载/system/usr/keychars/keypad.kcm.bin

 

例:

/sys/class/input/input1/name = keypad

则要打开的文件路径是:

/system/usr/keylayout/keypad.kl

/system/usr/keychars/keypad.kcm.bin

若以上文件不存在,则使用默认文件:

/system/usr/keylayout/qwerty.kl

/system/usr/keychars/qwerty.kcm.bin

7.4.2字符映射

文件:frameworks/base/core/java/android/view/KeyCharacterMap.java

public char getMatch(int keyCode, char[] chars)

    {

        return getMatch(keyCode, chars, 0);

    }

    public char getMatch(int keyCode, char[] chars, int modifiers)

    {

        if (chars == null) {

            // catch it here instead of in native

            throw new NullPointerException();

        }

        return getMatch_native(mPointer, keyCode, chars, modifiers);

}

getMatch_native 原型如下:

文件:frameworks/base/core/jni/android_text_KeyCharacterMap.cpp

static JNINativeMethod g_methods[] = {

    /* name, signature, funcPtr */

{ "getMatch_native",         "(II[CI)C", (void*)getMatch },

...

};

static jchar

getMatch(JNIEnv *env, jobject clazz, jint ptr, jint keycode, jcharArray chars, jint modifiers)

{

    jchar rv;

    jchar* ch = env->GetCharArrayElements(chars, NULL);

    jsize chsize = env->GetArrayLength(chars);

 

    rv = reinterpret_cast<KeyCharacterMap*>(ptr)->getMatch(keycode, ch, chsize, modifiers);

 

    env->ReleaseCharArrayElements(chars, ch, JNI_ABORT);

    return rv;

}

getMatch的原型如下:

文件:frameworks/base/libs/ui/KeyCharacterMap.cpp

unsigned short

KeyCharacterMap::getMatch(int keycode, const unsigned short* chars,

                          int charsize, uint32_t modifiers)

{

    Key* k = find_key(keycode);

    modifiers &= 3; // ignore the SYM key because we don't have keymap entries for it

    if (k != NULL) {

        const uint16_t* data = k->data;

        for (int j=0; j<charsize; j++) {

            uint16_t c = chars[j];

            for (int i=0; i<(META_MASK + 1); i++) {

                if ((modifiers == 0) || ((modifiers & i) != 0)) {

                    if (c == data[i]) {

                        return c;

                    }

                }

            }

        }

    }

    return 0;

}

 qwerty.kcm的部分配置:

[type=QWERTY]                                          

                                                       

# keycode       display number  base    caps    fn      caps_fn

                                                       

A               'A'     '2'     'a'     'A'     '#'     0x00

B               'B'     '2'     'b'     'B'     '<'     0x00

C               'C'     '2'     'c'     'C'     '9'     0x00E7

D               'D'     '3'     'd'     'D'     '5'     0x00

E               'E'     '3'     'e'     'E'     '2'     0x0301

F               'F'     '3'     'f'     'F'     '6'     0x00A5

G               'G'     '4'     'g'     'G'     '-'     '_'

H               'H'     '4'     'h'     'H'     '['     '{'

I               'I'     '4'     'i'     'I'     '$'     0x0302

J               'J'     '5'     'j'     'J'     ']'     '}'

找到keyCode对应的所有字符,然后再根据modifiers选择对应的字符

7.5 流程总结

当有按键响应时,内核传给ANDROID的是scancode,ANDROID将scancode经配置表(如qwerty.kl)找到keycode标识符,然后由内部表KEYCODES列表找到keycode的数字值,再由keycode的数字值经字符配置表(如qwerty.kcm)找到对应的字符值。

哨兵1号后向散射系数土壤水分反演 打开之前预处理之后的VH和VV极化的后向散射系数转存的tiff文件。 阅读详情

相关推荐

Windows应急响应实战:灰鸽子木马检测与清除全流程解析

远程控制木马(RAT)是一种基于客户端/服务器(C/S)架构的恶意软件,攻击者通过它能够远程操控受害主机,实现屏幕监控、文件窃取、键盘记录等操作,对个人隐私与企业数据安全构成严重威胁。其技术原理通常涉及进程注入、网络通信、持久化机制等核心环节,在应急响应中具有极高的分析价值。掌握此类木马的检测与清除方法,是Windows系统安全防护与事件处置的基本功。本文以经典的灰鸽子木马为例,结合进程分析、网络排查、注册表检查等实战技术,系统讲解从行为识别、痕迹取证到彻底清除的完整操作流程,并涵盖Rootkit对抗、无文

weixin_30521161的博客 416

Android软键盘的全面解析,让你不再怕控件被遮盖

本文出自博客Vander丶优快云博客,如需转载请标明出处,尊重原创谢谢 博客地址:http://blog.csdn.net/l540675759/article/details/74528641背景1.Android软键盘这块从我入职到现在,是一个一直纠缠我的问题。2.从布局挤压,到EditText显示不全,在到弹出时卡顿,在Android软键盘面前我无数次跌倒。3.因为网上大多数的知识点比较分

余杭探险家 3万+

ICM42670 IIC驱动与卡尔曼+四元数姿态解算实战

惯性测量单元(IMU)是运动控制、无人机飞控和AR/VR设备的核心传感器,其数据质量直接取决于底层硬件通信可靠性与姿态估计算法鲁棒性。IIC(I²C)作为嵌入式系统中最常用的低速串行总线,需满足确定性时序、抗干扰与实时采样要求;卡尔曼滤波则通过状态建模与噪声协方差优化,在动态环境中融合加速度计与陀螺仪数据;而四元数因其无万向锁、插值平滑、旋转合成高效等优势,成为高精度姿态解算的数学基础。本文以高性能六轴IMU ICM42670为载体,深入剖析IIC硬件设计要点、裸机级驱动优化、Allan方差驱动的卡尔曼参数

weixin_27076351的博客 258

Android线程优先级设置方法技巧

  对于Android平台上的线程优先级设置来说可以处理很多并发线程的阻塞问题,比如很多无关紧要的线程会占用大量的CPU时间,虽然通过了MultiThread来解决慢速I/O但是合理分配优先级对于并发编程来说十分重要。Android在线程方面主要使用的是Java本身的Thread类,我们可以在Thread或Runnable接口中的run方法首句加入Process.setThreadPrior

09的专栏 2940

ThingsBoard - 设备接入

设备接入笔记

qq_53839898的博客 1457

S32K344 Bootloader实战:一个按键实现从Boot到App的无缝跳转(附完整代码)

本文详细介绍了基于NXP S32K344微控制器的Bootloader开发实战,重点解析如何通过一个硬件按键实现从Boot到App的可靠跳转。内容涵盖内存分区规划、中断向量表重映射、外设初始状态管理等核心要素,并提供了完整的代码示例和调试技巧,适用于汽车电子和工业控制等高可靠性应用场景。

weixin_29192365的博客 309

Android中进程线程调度的命令之nice

nice与进程调度Linux中,使用nice value(以下成为nice值)来设定一个进程的优先级,系统任务调度器根据nice值合理安排调度。nice的取值范围为-20到19。 通常情况下,nice的默认值为0。视具体操作系统而定。 nice的值越大,进程的优先级就越低,获得CPU调用的机会越少,nice值越小,进程的优先级则越高,获得CPU调用的机会越多。 一个nice值为-20的进程优先级最高

做你所想,想你所做。 8182

零信任实战:Tetragon阻断容器运行时0day攻击

零信任容器安全防御:Tetragon实战探析 摘要:针对容器0day攻击防护难题,本文提出基于Tetragon的eBPF零信任防御方案。通过内核级系统调用监控(如execve、mount),结合动态行为分析,实现3ms级攻击阻断。实战案例显示:成功拦截Log4j2漏洞利用(JNDI注入前阻断)和未知容器逃逸(/proc敏感路径防护)。某银行部署后实现100%攻击拦截率,性能损耗<3%,安全响应时间从30分钟降至5秒。方案突破传统防御瓶颈,为容器运行时安全提供新范式。

python,运维,测试,数据分析,人工智能 766

Processing入门教程(五)鼠标键盘事件

void setup() { size(584, 414, P3D); frameRate(60); line(30, 20, 0, 85, 20, 15); stroke(126); line(85, 20, 15, 85, 75, 0); stroke(255); line(85, 75, 0, 30, 75, -50); } void draw() { } v...

我知道你很急,但是路要一步步走 5380

帝企鹅优化器(EPO)详解:从基础原理到代码实战

帝企鹅优化器(EPO)是受帝企鹅群体在极寒环境中抱团取暖行为启发,于2018年提出的一种群体智能优化算法。其核心机制是模拟帝企鹅种群通过动态调整位置来维持体温的过程,主要包括确定集群边界、计算温度分布、衡量个体间距离以及更新位置四个步骤,从而在求解复杂优化问题时有效平衡全局探索与局部开发。该算法具有参数少、结构清晰、易于实现等优点,在工程优化、图像处理、机器学习特征选择以及冷链物流车辆路径规划等领域展现出良好的应用潜力。

qq_42212808的博客 141

【sealos安装指南】基于 Sealos 安装 Kubernetes 1.33.6 高可用集群

本文介绍使用Sealos工具快速搭建Kubernetes集群的详细指南。Sealos简化了K8s部署流程,自动完成系统调优,适合新手学习使用。文章提供了服务器规划、环境准备、在线/离线两种安装方式的具体步骤,包括主机名设置、swap关闭、数据目录配置等。重点讲解了Sealos的安装命令参数说明,以及添加/删除节点等常用操作。推荐使用Calico网络组件确保稳定性,并附有安装成功后的验证截图。该指南能帮助用户快速搭建一个包含master和worker节点的K8s集群,底层基于containerd运行。

欢迎你们到来,希望能帮到大家 464

【转】ADROID 2.1 架构解析 7 键盘

<br />原文出处: http://blog.csdn.net/skdev/archive/2010/03/08/5355542.aspx<br /> <br /> <br />7 键盘<br />系统在KeyInputQueue服务里创建了一个线程,在这个线程里不断读取输入事件,然后对这个事件进行处理。<br />7.1 按键输入队列服务<br />按键输入事件有多种方式,如:键盘敲击、触摸屏触击、鼠标点击及多点触摸,主要是按下和放开的事件。<br />7.1.1 输入事件的数据结构<br />文件:f

android83的专栏 783

用「OpenClaw」打造新媒体运营神器:小红书/公众号全自动选题→创作→排版→发布全流程

对于新媒体运营的从业者来说,AI不是要取代运营人员,而是把他们从繁琐的重复劳动中解放出来,专注于更核心的内容策略、用户运营、品牌建设,这才是AI在传统行业落地的真正价值。这是最终输出可发布内容的核心智能体,我们通过「OpenClaw」的Prompt工程,结合不同平台的排版规范,实现了一键生成符合要求的排版,完全替代人工重复劳动。这套系统的落地,不是技术的炫技,而是真正用AI解决了新媒体运营的核心痛点:用自动化替代重复的人工劳动,用数据决策替代经验主义,用全闭环执行替代纸上谈兵的建议。

专注于Python爬虫开发,分享爬虫技巧、项目实战与反爬经验,使用Scrapy、BeautifulSoup等工具,解决数据抓取难题。 200

ADROID 架构解析及驱动 键盘篇

ADROID 架构解析及驱动 键盘篇 一、用户空间            ADROID 2.1 架构解析 7 键盘      以上链接,详细介绍了Android用户空间按键的操作,最终通过不断轮询所有设备,直到读取有POLLIN事件产生的设备状态:if(mFDs[i].revents & POLLIN) {res = read(mFDs[i].fd, &iev, sizeof(i

gooogleman#foxmail.com 3623

visio安装包

Microsoft Office Visio 是一款专业的制图软件。利用经过更新的形状、协作工具和数据链接图表,创建专业级图表以简化复杂的信息。

VB摄像头监控

该VB模块可对摄像头捕获的画面进行录像等,可在创建的窗口进行控制

Android 架构解析及驱动 键盘篇

Android 架构解析及驱动 键盘篇 --  作者:老树 --  发布时间:2010-6-2 15:01:19--  Android 架构解析及驱动 键盘篇一、用户空间            ADROID 2.1 架构解析 7 键盘     以上链接,详细介绍了Android用户空间按键的操作,最终通过不断轮询所有设备,直到读取有POLLIN事件产生的设备状态:if(mFDs[i].revents & POLLIN) {res = read(mFDs[i].fd, &iev, sizeof(iev))

csu_yang的专栏 1476

最新的sdio 4.0 spec 协议标准 带书签 高清完整PDF版

Part-E1-SDIO-Specification-Ver4.00-Final-120220.pdf:最新的sdio 4.0 spec 协议标准 带书签 高清完整PDF版,包括SDIO 接口的外设,SDIO 接口官方协议等。

ADROID 2.1 架构解析 8 触摸屏

原文地址:http://blog.csdn.net/skdev/archive/2010/03/08/5357358.aspx 8 触摸屏8.1 分类输入事件文件:frameworks/base/libs/ui/EventHub.cpp// 输入事件有:键盘、轨迹球、单点触摸、多点触摸 int EventHub::open_device(const char *deviceName) { ... uint8_t key_bitmask[(KEY_MAX+1)/8];

android83的专栏 811

汉书HE8,好用的汇编代码编写工具

汉书HE8,好用的汇编代码编写工具早期编写汇编代码所用功能强大

Adroid软键盘处理

windowSoftInputMode属性设置值说明。                          "stateUnchanged", "stateHidden",                          "stateAlwaysHidden", "stateVisible",                          "stateAlwaysVisible","

一个踩这七色彩虹的路人甲 267
上一篇: ADROID 2.1 架构解析 6 闹钟
下一篇: ADROID 2.1 架构解析 8 触摸屏
skdev
博客等级 码龄20年 139粉丝 84原创
评论 8
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值