Input系統(tǒng)之InputReader概要性實例分析
更新時間：2022年11月10日 15:30:02 作者：大胃粥
這篇文章主要介紹為大家了Input系統(tǒng)之InputReader概要性實例分析，有需要的朋友可以借鑒參考下，希望能夠有所幫助，祝大家多多進步，早日升職加薪
InputReader 的創(chuàng)建
從 InputManagerService: 創(chuàng)建與啟動 可知，Input 系統(tǒng)的主要功能，主要集中在 native 層，并且Input 系統(tǒng)的 native 層又包含 InputReader, InputClassifer, InputDispatcher 三個子模塊。本文來分析 InputReader 從創(chuàng)建到啟動的基本流程，為后續(xù)分析 InputReader 的每一個功能打好基礎。
從 InputManagerService: 創(chuàng)建與啟動 可知， InputReader 的創(chuàng)建過程如下
// InputReaderFactory.cpp
sp<InputReaderInterface> createInputReader(const sp<InputReaderPolicyInterface>& policy,
const sp<InputListenerInterface>& listener) {
return new InputReader(std::make_unique<EventHub>(), policy, listener);
}
InputReader 依賴 EventHub，因此首先要看下 EventHub 的創(chuàng)建過程
EventHub::EventHub(void)
: mBuiltInKeyboardId(NO_BUILT_IN_KEYBOARD),
mNextDeviceId(1),
mControllerNumbers(),
mNeedToSendFinishedDeviceScan(false),
mNeedToReopenDevices(false),
mNeedToScanDevices(true), // mNeedToScanDevices 初始化為 true，表示需要掃描輸入設備
mPendingEventCount(0),
mPendingEventIndex(0),
mPendingINotify(false) {
ensureProcessCanBlockSuspend();
// 1. 創(chuàng)建 epoll
mEpollFd = epoll_create1(EPOLL_CLOEXEC);
// 2. 初始化 inotify
mINotifyFd = inotify_init();
// 監(jiān)聽 /dev/input/ 目錄項的創(chuàng)建與刪除，其實就是監(jiān)聽輸入設備的創(chuàng)建與刪除
mInputWd = inotify_add_watch(mINotifyFd, DEVICE_PATH, IN_DELETE | IN_CREATE);
// ...
// 3. epoll 監(jiān)聽 inotify 事件
// 可讀事件，表明有輸入設備的創(chuàng)建與刪除
struct epoll_event eventItem = {};
eventItem.events = EPOLLIN | EPOLLWAKEUP;
eventItem.data.fd = mINotifyFd;
int result = epoll_ctl(mEpollFd, EPOLL_CTL_ADD, mINotifyFd, &eventItem);
// 4. 創(chuàng)建管道
int wakeFds[2];
result = pipe(wakeFds);
mWakeReadPipeFd = wakeFds[0];
mWakeWritePipeFd = wakeFds[1];
// 設置管道兩端為非阻塞
result = fcntl(mWakeReadPipeFd, F_SETFL, O_NONBLOCK);
result = fcntl(mWakeWritePipeFd, F_SETFL, O_NONBLOCK);
// 5. epoll 監(jiān)聽管道讀端的事件
// 可讀事件，表明需要喚醒 InputReader 線程，觸發(fā)條件一般為配置更新
eventItem.data.fd = mWakeReadPipeFd;
result = epoll_ctl(mEpollFd, EPOLL_CTL_ADD, mWakeReadPipeFd, &eventItem);
}
EventHub 創(chuàng)建過程如下
- 創(chuàng)建 epoll 實例。
- 初始化 inotify 實例，并用 epoll 監(jiān)聽它的事件。當輸入設備添加/刪除時，epoll 就會收到 inotify 的可讀事件，因此 EventHub 和 InputReader 就可以動態(tài)地處理輸入設備的添加/刪除。
- 創(chuàng)建管道。
- epoll 監(jiān)聽管道的讀端的事件。當配置更新時，會向管道的寫端寫入數(shù)據(jù)，epoll 就會收到管道的可讀事件，如果此時 InputReader 線程處于休眠狀態(tài)，那么 InputReader 將被喚醒來處于配置更新。
epoll, inotify, pipe，它們的作用和使用方式，請讀者自行查閱 Unix/Linux 資料。
現(xiàn)在讓我們繼續(xù)看下 InputReader 的創(chuàng)建過程
InputReader::InputReader(std::shared_ptr<EventHubInterface> eventHub,
const sp<InputReaderPolicyInterface>& policy,
const sp<InputListenerInterface>& listener)
: mContext(this), // mContext 代表 InputReader 的環(huán)境
mEventHub(eventHub),
mPolicy(policy),
mGlobalMetaState(0),
mLedMetaState(AMETA_NUM_LOCK_ON),
mGeneration(1),
mNextInputDeviceId(END_RESERVED_ID),
mDisableVirtualKeysTimeout(LLONG_MIN),
mNextTimeout(LLONG_MAX),
mConfigurationChangesToRefresh(0) {
// InputReader 會把加工后的事件添加到 QueuedInputListener 隊列中，之后一起分發(fā)給 InputClassifier
mQueuedListener = new QueuedInputListener(listener);
{ // acquire lock
std::scoped_lock _l(mLock);
// 刷新配置
// 其實就是更新 InputReader::mConfig
refreshConfigurationLocked(0);
// 更新 InputReader::mGlobalMetaState
// 與鍵盤輸入設備的meta按鍵相關
updateGlobalMetaStateLocked();
} // release lock
}
InputReader 的構造函數(shù)很簡單，就是成員變量的初始化。其中需要重點看下 refreshConfigurationLocked(0) 是如何刷新 InputReader 配置
// 注意，此時參數(shù) changes 為 0
void InputReader::refreshConfigurationLocked(uint32_t changes) {
// 通過 InputReaderPolicyInterface 獲取配置，保存到 InputReader::mConfig 中
mPolicy->getReaderConfiguration(&mConfig);
// EventHub 保存排除的設備
mEventHub->setExcludedDevices(mConfig.excludedDeviceNames);
if (!changes) return;
// ...
}
原來 InputReader::mConfig 代表的就是 InputReader 的配置，并且是通過 InputReaderPolicyInterface mPolicy 獲取配置的。
從 InputManagerService: 創(chuàng)建與啟動 可知，InputReaderPolicyInterface 接口的實現(xiàn)者是 NativeInputManager ，而 NativeInputManager 是 Input 系統(tǒng)的上層與底層溝通的橋梁，因此 InputReader 必定是通過 NativeInputManager 向上層獲取配置
void NativeInputManager::getReaderConfiguration(InputReaderConfiguration* outConfig) {
ATRACE_CALL();
JNIEnv* env = jniEnv();
// 1. 通過JNI，向上層 InputManagerService 獲取配置，并保存到 outConfig 中
jint virtualKeyQuietTime = env->CallIntMethod(mServiceObj,
gServiceClassInfo.getVirtualKeyQuietTimeMillis);
if (!checkAndClearExceptionFromCallback(env, "getVirtualKeyQuietTimeMillis")) {
outConfig->virtualKeyQuietTime = milliseconds_to_nanoseconds(virtualKeyQuietTime);
}
outConfig->excludedDeviceNames.clear();
jobjectArray excludedDeviceNames = jobjectArray(env->CallStaticObjectMethod(
gServiceClassInfo.clazz, gServiceClassInfo.getExcludedDeviceNames));
if (!checkAndClearExceptionFromCallback(env, "getExcludedDeviceNames") && excludedDeviceNames) {
jsize length = env->GetArrayLength(excludedDeviceNames);
for (jsize i = 0; i < length; i++) {
std::string deviceName = getStringElementFromJavaArray(env, excludedDeviceNames, i);
outConfig->excludedDeviceNames.push_back(deviceName);
}
env->DeleteLocalRef(excludedDeviceNames);
}
// Associations between input ports and display ports
// The java method packs the information in the following manner:
// Original data: [{'inputPort1': '1'}, {'inputPort2': '2'}]
// Received data: ['inputPort1', '1', 'inputPort2', '2']
// So we unpack accordingly here.
outConfig->portAssociations.clear();
jobjectArray portAssociations = jobjectArray(env->CallObjectMethod(mServiceObj,
gServiceClassInfo.getInputPortAssociations));
if (!checkAndClearExceptionFromCallback(env, "getInputPortAssociations") && portAssociations) {
jsize length = env->GetArrayLength(portAssociations);
for (jsize i = 0; i < length / 2; i++) {
std::string inputPort = getStringElementFromJavaArray(env, portAssociations, 2 * i);
std::string displayPortStr =
getStringElementFromJavaArray(env, portAssociations, 2 * i + 1);
uint8_t displayPort;
// Should already have been validated earlier, but do it here for safety.
bool success = ParseUint(displayPortStr, &displayPort);
if (!success) {
ALOGE("Could not parse entry in port configuration file, received: %s",
displayPortStr.c_str());
continue;
}
outConfig->portAssociations.insert({inputPort, displayPort});
}
env->DeleteLocalRef(portAssociations);
}
outConfig->uniqueIdAssociations.clear();
jobjectArray uniqueIdAssociations = jobjectArray(
env->CallObjectMethod(mServiceObj, gServiceClassInfo.getInputUniqueIdAssociations));
if (!checkAndClearExceptionFromCallback(env, "getInputUniqueIdAssociations") &&
uniqueIdAssociations) {
jsize length = env->GetArrayLength(uniqueIdAssociations);
for (jsize i = 0; i < length / 2; i++) {
std::string inputDeviceUniqueId =
getStringElementFromJavaArray(env, uniqueIdAssociations, 2 * i);
std::string displayUniqueId =
getStringElementFromJavaArray(env, uniqueIdAssociations, 2 * i + 1);
outConfig->uniqueIdAssociations.insert({inputDeviceUniqueId, displayUniqueId});
}
env->DeleteLocalRef(uniqueIdAssociations);
}
jint hoverTapTimeout = env->CallIntMethod(mServiceObj,
gServiceClassInfo.getHoverTapTimeout);
if (!checkAndClearExceptionFromCallback(env, "getHoverTapTimeout")) {
jint doubleTapTimeout = env->CallIntMethod(mServiceObj,
gServiceClassInfo.getDoubleTapTimeout);
if (!checkAndClearExceptionFromCallback(env, "getDoubleTapTimeout")) {
jint longPressTimeout = env->CallIntMethod(mServiceObj,
gServiceClassInfo.getLongPressTimeout);
if (!checkAndClearExceptionFromCallback(env, "getLongPressTimeout")) {
outConfig->pointerGestureTapInterval = milliseconds_to_nanoseconds(hoverTapTimeout);
// We must ensure that the tap-drag interval is significantly shorter than
// the long-press timeout because the tap is held down for the entire duration
// of the double-tap timeout.
jint tapDragInterval = max(min(longPressTimeout - 100,
doubleTapTimeout), hoverTapTimeout);
outConfig->pointerGestureTapDragInterval =
milliseconds_to_nanoseconds(tapDragInterval);
}
}
}
jint hoverTapSlop = env->CallIntMethod(mServiceObj,
gServiceClassInfo.getHoverTapSlop);
if (!checkAndClearExceptionFromCallback(env, "getHoverTapSlop")) {
outConfig->pointerGestureTapSlop = hoverTapSlop;
}
// 2. 從 NativeInputManager::mLocked 更新配置，保存到 outConfig 中
// NativeInputManager::mLocked 的數(shù)據(jù)是上層經(jīng)由 InputManagerService 傳入的
{ // acquire lock
AutoMutex _l(mLock);
outConfig->pointerVelocityControlParameters.scale = exp2f(mLocked.pointerSpeed
* POINTER_SPEED_EXPONENT);
outConfig->pointerGesturesEnabled = mLocked.pointerGesturesEnabled;
outConfig->showTouches = mLocked.showTouches;
outConfig->pointerCapture = mLocked.pointerCapture;
outConfig->setDisplayViewports(mLocked.viewports);
outConfig->defaultPointerDisplayId = mLocked.pointerDisplayId;
outConfig->disabledDevices = mLocked.disabledInputDevices;
} // release lock
}
從整體看，獲取 InputReader 配置的方式有兩種
- 通過 JNI 向上層的 InputManagerService 獲取配置。
- 從 NativeInputManager::mLocked 獲取配置。
從 InputManagerService: 創(chuàng)建與啟動 可知，NativeInputManager::mLocked 是在 NativeInputManager 的構造函數(shù)中進行初始化的，但是它并不是不變的，而是上層經(jīng)由 InputManagerService 進行操控的。
例如，mLocked.showTouches 對應開發(fā)者模式下的 Show taps 功能，InputManagerService 會監(jiān)聽這個開關的狀態(tài)，相應地改變 mLocked.showTouches，并且會通知 InputReader 配置改變了，InputReader 在處理配置改變的過程時，會重新獲取 mLocked.showTouches 這個配置。
有 一部分 的配置是可以通過 adb shell dumpsys input 命令進行查看的
Input Manager State: Interactive: true System UI Lights Out: false Pointer Speed: 0 Pointer Gestures Enabled: true Show Touches: false Pointer Capture: Disabled, seq=0
而另外一部分配置，由于會對輸入設備進行配置，因此可以從 dump 出的輸入設備的信息中查看。
InputReader 的運行
從 InputManagerService: 創(chuàng)建與啟動 可知，InputReader 通過線程，循環(huán)調用 InputReader::loopOnce() 執(zhí)行任務
void InputReader::loopOnce() {
int32_t oldGeneration;
int32_t timeoutMillis;
bool inputDevicesChanged = false;
std::vector<InputDeviceInfo> inputDevices;
{ // acquire lock
std::scoped_lock _l(mLock);
oldGeneration = mGeneration;
timeoutMillis = -1;
// 1. 如果配置有改變，那么就刷新配置
uint32_t changes = mConfigurationChangesToRefresh;
if (changes) {
mConfigurationChangesToRefresh = 0;
timeoutMillis = 0;
// 刷新配置
refreshConfigurationLocked(changes);
} else if (mNextTimeout != LLONG_MAX) {
nsecs_t now = systemTime(SYSTEM_TIME_MONOTONIC);
timeoutMillis = toMillisecondTimeoutDelay(now, mNextTimeout);
}
} // release lock
// 2. 從 EventHub 獲取事件
size_t count = mEventHub->getEvents(timeoutMillis, mEventBuffer, EVENT_BUFFER_SIZE);
{ // acquire lock
std::scoped_lock _l(mLock);
mReaderIsAliveCondition.notify_all();
// 3. 處理事件
if (count) {
processEventsLocked(mEventBuffer, count);
}
if (mNextTimeout != LLONG_MAX) {
nsecs_t now = systemTime(SYSTEM_TIME_MONOTONIC);
if (now >= mNextTimeout) {
mNextTimeout = LLONG_MAX;
timeoutExpiredLocked(now);
}
}
// 4. 處理輸入設備改變
// 4.1 輸入設備改變，重新獲取輸入設備信息
if (oldGeneration != mGeneration) {
inputDevicesChanged = true;
inputDevices = getInputDevicesLocked();
}
} // release lock
// 4.2 通知監(jiān)聽者，輸入設備改變了
if (inputDevicesChanged) {
mPolicy->notifyInputDevicesChanged(inputDevices);
}
// 5. 刷新隊列中緩存的事件
// 其實就是把事件分發(fā)給 InputClassifier
mQueuedListener->flush();
}
InputReader 所做的事情如下
- 如果配置改變了，那么就更新配置。
- 從 EventHub 獲取事件，并處理獲取到的事件。在處理事件的過程中，InputReader 會對事件進行加工，然后保存到 QueuedInputListener 緩存隊列中。
- 如果設備發(fā)生改變，那么重新獲取新的設備信息，并通知監(jiān)聽者。
- QueuedInputListener 刷新緩存的事件，其實就是把 InputReader 加工后的事件分發(fā)給 InputClassifer。
EventHub 提供事件
InputReader 的本質就是處理從 EventHub 獲取的事件，然后分發(fā)給下一環(huán)。因為我們必須了解 EventHub::getEvents() 是如何為 InputReader 提供事件的
// EventHub.cpp
size_t EventHub::getEvents(int timeoutMillis, RawEvent* buffer, size_t bufferSize) {
ALOG_ASSERT(bufferSize >= 1);
std::scoped_lock _l(mLock);
struct input_event readBuffer[bufferSize];
RawEvent* event = buffer;
size_t capacity = bufferSize;
bool awoken = false;
for (;;) {
nsecs_t now = systemTime(SYSTEM_TIME_MONOTONIC);
// Reopen input devices if needed.
if (mNeedToReopenDevices) {
// ...
}
// Report any devices that had last been added/removed.
for (auto it = mClosingDevices.begin(); it != mClosingDevices.end();) {
// ...
}
// 掃描輸入設備
if (mNeedToScanDevices) {
mNeedToScanDevices = false;
scanDevicesLocked();
mNeedToSendFinishedDeviceScan = true;
}
// 為掃描后打開的每一個輸入設備，填充一個類型為 DEVICE_ADDED 的事件
while (!mOpeningDevices.empty()) {
std::unique_ptr<Device> device = std::move(*mOpeningDevices.rbegin());
mOpeningDevices.pop_back();
event->when = now;
event->deviceId = device->id == mBuiltInKeyboardId ? 0 : device->id;
event->type = DEVICE_ADDED;
event += 1;
// Try to find a matching video device by comparing device names
for (auto it = mUnattachedVideoDevices.begin(); it != mUnattachedVideoDevices.end();
it++) {
// ...
}
// 每次填充完事件，就把設備 Device 保存到 mDevices 中
auto [dev_it, inserted] = mDevices.insert_or_assign(device->id, std::move(device));
if (!inserted) {
ALOGW("Device id %d exists, replaced.", device->id);
}
// 表明你需要發(fā)送設備掃描完成事件
mNeedToSendFinishedDeviceScan = true;
if (--capacity == 0) {
break;
}
}
// 填充設備掃描完成事件
if (mNeedToSendFinishedDeviceScan) {
mNeedToSendFinishedDeviceScan = false;
event->when = now;
event->type = FINISHED_DEVICE_SCAN;
event += 1;
if (--capacity == 0) {
break;
}
}
// Grab the next input event.
bool deviceChanged = false;
// 處理 epoll 事件
while (mPendingEventIndex < mPendingEventCount) {
// 處理 inotify 事件，表明輸入設備新增或者刪除
const struct epoll_event& eventItem = mPendingEventItems[mPendingEventIndex++];
if (eventItem.data.fd == mINotifyFd) {
if (eventItem.events & EPOLLIN) {
mPendingINotify = true;
} else {
ALOGW("Received unexpected epoll event 0x%08x for INotify.", eventItem.events);
}
continue;
}
// 處理管道事件，這是用來喚醒 InputReader 線程
if (eventItem.data.fd == mWakeReadPipeFd) {
if (eventItem.events & EPOLLIN) {
ALOGV("awoken after wake()");
awoken = true;
char wakeReadBuffer[16];
ssize_t nRead;
do {
nRead = read(mWakeReadPipeFd, wakeReadBuffer, sizeof(wakeReadBuffer));
} while ((nRead == -1 && errno == EINTR) || nRead == sizeof(wakeReadBuffer));
} else {
ALOGW("Received unexpected epoll event 0x%08x for wake read pipe.",
eventItem.events);
}
continue;
}
// 接下來是處理設備的輸入事件
Device* device = getDeviceByFdLocked(eventItem.data.fd);
if (device == nullptr) {
continue;
}
if (device->videoDevice && eventItem.data.fd == device->videoDevice->getFd()) {
// ...
}
if (eventItem.events & EPOLLIN) {
// 讀取輸入事件以及數(shù)量
int32_t readSize =
read(device->fd, readBuffer, sizeof(struct input_event) * capacity);
if (readSize == 0 || (readSize < 0 && errno == ENODEV)) {
// Device was removed before INotify noticed.
ALOGW("could not get event, removed? (fd: %d size: %" PRId32
" bufferSize: %zu capacity: %zu errno: %d)\n",
device->fd, readSize, bufferSize, capacity, errno);
deviceChanged = true;
closeDeviceLocked(*device);
} else if (readSize < 0) {
if (errno != EAGAIN && errno != EINTR) {
ALOGW("could not get event (errno=%d)", errno);
}
} else if ((readSize % sizeof(struct input_event)) != 0) {
ALOGE("could not get event (wrong size: %d)", readSize);
} else {
int32_t deviceId = device->id == mBuiltInKeyboardId ? 0 : device->id;
// 為每一個輸入事件，填充一個事件
size_t count = size_t(readSize) / sizeof(struct input_event);
for (size_t i = 0; i < count; i++) {
struct input_event& iev = readBuffer[i];
event->when = processEventTimestamp(iev);
event->readTime = systemTime(SYSTEM_TIME_MONOTONIC);
event->deviceId = deviceId;
event->type = iev.type;
event->code = iev.code;
event->value = iev.value;
event += 1;
capacity -= 1;
}
if (capacity == 0) {
// The result buffer is full. Reset the pending event index
// so we will try to read the device again on the next iteration.
mPendingEventIndex -= 1;
break;
}
}
} else if (eventItem.events & EPOLLHUP) {
ALOGI("Removing device %s due to epoll hang-up event.",
device->identifier.name.c_str());
deviceChanged = true;
closeDeviceLocked(*device);
} else {
ALOGW("Received unexpected epoll event 0x%08x for device %s.", eventItem.events,
device->identifier.name.c_str());
}
}
// 處理設備改變
// mPendingEventIndex >= mPendingEventCount 表示處理完所有的輸入事件后，再處理設備的改變
if (mPendingINotify && mPendingEventIndex >= mPendingEventCount) {
mPendingINotify = false;
readNotifyLocked();
deviceChanged = true;
}
// 設備發(fā)生改變，那么跳過當前循環(huán)，在下一個循環(huán)的開頭處理設備改變
if (deviceChanged) {
continue;
}
// 如果有事件，或者被喚醒，那么終止循環(huán)，接下來 InputReader 會處理事件或者更新配置
if (event != buffer || awoken) {
break;
}
mPendingEventIndex = 0;
mLock.unlock(); // release lock before poll
// 此時沒有事件，并且也沒有被喚醒，那么超時等待 epoll 事件
int pollResult = epoll_wait(mEpollFd, mPendingEventItems, EPOLL_MAX_EVENTS, timeoutMillis);
mLock.lock(); // reacquire lock after poll
if (pollResult == 0) {
// 處理超時...
}
if (pollResult < 0) {
// 處理錯誤...
} else {
// 保存待處理事件的數(shù)量
mPendingEventCount = size_t(pollResult);
}
}
// 返回事件的數(shù)量
return event - buffer;
}
EventHub::getEvent() 提供事件的過程很長，但是現(xiàn)在我們不必去了解所有的細節(jié)，我們要有從整體看局部的眼光。EventHub 其實只生成了兩類事件
- 設備的添加/刪除事件。這種事件不是通過操作設備而產生的，系統(tǒng)稱之為合成事件。
- 輸入事件。這種事件是通過操作設備產生的，例如手指在觸摸屏上滑動，系統(tǒng)稱之為元輸入事件。
看來我們得分兩部分來分析這兩類事件的生成以及處理過程，因此下一篇文章，我們分析合成事件的生成以及處理過程。
以上就是Input系統(tǒng)之InputReader概要性實例分析的詳細內容，更多關于Input系統(tǒng)InputReader概要性的資料請關注腳本之家其它相關文章！
相關文章
Android貝塞爾曲線初步學習第二課 仿QQ未讀消息氣泡拖拽黏連效果
這篇文章主要為大家詳細介紹了Android貝塞爾曲線初步學習的第二課，仿QQ未讀消息氣泡拖拽黏連效果，具有一定的參考價值，感興趣的小伙伴們可以參考一下2017-03-03
這篇文章主要介紹了從原生Android 跳轉到hbuilder項目，小編覺得挺不錯的，現(xiàn)在分享給大家，也給大家做個參考。一起跟隨小編過來看看吧2018-08-08
這篇文章主要介紹了android實現(xiàn)圓角矩形背景的方法,以實例形式分析了Android編程實現(xiàn)圓角矩形背景的相關技巧,具有一定參考借鑒價值,需要的朋友可以參考下2015-10-10
Android開發(fā)筆記之:返回鍵的復寫onBackPressed()介紹
本篇文章是對Android中返回鍵的復寫onBackPressed()進行了詳細的分析介紹，需要的朋友參考下2013-05-05
Android 圖片特效處理的方法實例，需要的朋友可以參考一下2013-03-03
這篇文章主要為大家詳細介紹了Android實現(xiàn)讀取NFC卡的編號，文中示例代碼介紹的非常詳細，具有一定的參考價值，感興趣的小伙伴們可以參考一下2021-09-09
Android Studio下載、安裝和配置+SDK+tools下載(無敵超級詳細版本)
這篇文章主要介紹了Android Studio下載、安裝和配置+SDK+tools下載(無敵超級詳細版本)，文中通過示例代碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值，需要的朋友們下面隨著小編來一起學習學習吧2020-11-11
本文通過實例代碼給大家講解了Android 隱藏底部虛擬鍵的兩種方法，非常不錯，具有一定的參考借鑒價值，需要的朋友參考下吧2018-07-07
這篇文章主要介紹了Android Activity跳轉動畫效果,本文圖文并茂給大家介紹的非常詳細，需要的朋友可以參考下2017-02-02
這篇文章主要介紹了Android開發(fā)自學筆記（二）：工程文件剖析,本文講解了AndroidManifest.xml、src文件夾、res文件夾等文件的作用,需要的朋友可以參考下2015-04-04