mPhaseOffsets->getOffsetThresholdForNextVsync(),
resyncCallback,
impl::EventThread::InterceptVSyncsCallback());
…
}
spScheduler::ConnectionHandle Scheduler::createConnection(
const char* connectionName, nsecs_t phaseOffsetNs, nsecs_t offsetThresholdForNextVsync,
ResyncCallback resyncCallback,
impl::EventThread::InterceptVSyncsCallback interceptCallback) {
//对应的id,累加的
const int64_t id = sNextId++;
//创建一个EventThread,名称为传入的connectionName
std::unique_ptr eventThread =
makeEventThread(connectionName, mPrimaryDispSync.get(), phaseOffsetNs,
offsetThresholdForNextVsync, std::move(interceptCallback));
//创建EventThreadConnection
auto eventThreadConnection = createConnectionInternal(eventThread.get(), std::move(resyncCallback),
ISurfaceComposer::eConfigChangedSuppress);
//创建ConnectionHandle,入参是id,
//然后将创建的connection并存入到map中。key是id。
mConnections.emplace(id,
std::make_unique(new ConnectionHandle(id),
eventThreadConnection,
std::move(eventThread)));
return mConnections[id]->handle;
}
这里创建的Handler,持有了对应的EventThread,而eventThreadConnection是通过EventThread来进行创建。创建eventThreadConnection以后,会将其保存到map中,对应的key则是id信息。
而连接处理器:ConnectionHandle则是一个持有id的对象。
我们回到主线。。。。
mScheduler->createDisplayEventConnection
// frameworks\native\services\surfaceflinger\Scheduler\Scheduler.cpp
sp Scheduler::createDisplayEventConnection(
const spScheduler::ConnectionHandle& handle, ResyncCallback resyncCallback,
ISurfaceComposer::ConfigChanged configChanged) {
RETURN_VALUE_IF_INVALID(nullptr);
//传入了handle.id。能够表明连接是app还是surfaceFlinger
return createConnectionInternal(mConnections[handle->id]->thread.get(),
std::move(resyncCallback), configChanged);
}
sp Scheduler::createConnectionInternal(
EventThread* eventThread, ResyncCallback&& resyncCallback,
ISurfaceComposer::ConfigChanged configChanged) {
//调用EventThread的方法,创建事件连接器
return eventThread->createEventConnection(std::move(resyncCallback), configChanged);
}
我们看看事件连接器EventThreadConnection的创建过程
sp EventThread::createEventConnection(
ResyncCallback resyncCallback, ISurfaceComposer::ConfigChanged configChanged) const {
return new EventThreadConnection(const_cast<EventThread*>(this), std::move(resyncCallback),
configChanged);
}
EventThreadConnection::EventThreadConnection(EventThread* eventThread,
ResyncCallback resyncCallback,
ISurfaceComposer::ConfigChanged configChanged)
: resyncCallback(std::move(resyncCallback)),
configChanged(configChanged),
mEventThread(eventThread),
mChannel(gui::BitTube::DefaultSize) {}
EventThreadConnection的构造方法中最重要的是创建了mChannel,而它是gui::BitTube类型的
// frameworks\native\libs\gui\BitTube.cpp
BitTube::BitTube(size_t bufsize) {
init(bufsize, bufsize);
}
void BitTube::init(size_t rcvbuf, size_t sndbuf) {
int sockets[2];
if (socketpair(AF_UNIX, SOCK_SEQPACKET, 0, sockets) == 0) {
size_t size = DEFAULT_SOCKET_BUFFER_SIZE;
//创建对应一对socket:0和1,一个用来读,一个用来写。
setsockopt(sockets[0], SOL_SOCKET, SO_RCVBUF, &rcvbuf, sizeof(rcvbuf));
setsockopt(sockets[1], SOL_SOCKET, SO_SNDBUF, &sndbuf, sizeof(sndbuf));
// since we don’t use the “return channel”, we keep it small…
setsockopt(sockets[0], SOL_SOCKET, SO_SNDBUF, &size, sizeof(size));
setsockopt(sockets[1], SOL_SOCKET, SO_RCVBUF, &size, sizeof(size));
fcntl(sockets[0], F_SETFL, O_NONBLOCK);
fcntl(sockets[1], F_SETFL, O_NONBLOCK);
//将mReceiveFd文件和socket进行绑定。当Vsync到来的时候,会通过mSendFd文件来写入消息,通过对文件的消息写入监听,完成了对Vsync信号的监听
mReceiveFd.reset(sockets[0]);
mSendFd.reset(sockets[1]);
} else {
mReceiveFd.reset();
}
}
在初始化方法中,创建了一对socket,然后将mReceiveFd和mSendFd进行了绑定。当Vsync到来的时候通过mSendFd写入消息,然后APP就可以监听文件的变化。
在创建EventThreadConnection对象的时候,会自动调用onFirstRef方法。
void EventThreadConnection::onFirstRef() {
mEventThread->registerDisplayEventConnection(this);
}
status_t EventThread::registerDisplayEventConnection(const sp& connection) {
std::lock_guardstd::mutex lock(mMutex);
// this should never happen
auto it = std::find(mDisplayEventConnections.cbegin(),
mDisplayEventConnections.cend(), connection);
if (it != mDisplayEventConnections.cend()) {
ALOGW(“DisplayEventConnection %p already exists”, connection.get());
mCondition.notify_all();
return ALREADY_EXISTS;
}
//将连接放入到需要通知的列表中。
mDisplayEventConnections.push_back(connection);
//有新的连接了,就需要唤醒AppEventThread线程使能Vsync信号了。
mCondition.notify_all();
return NO_ERROR;
}
会将我们创建的连接放入到EventThread管理的mDisplayEventConnections中,然后唤醒AppEventThread线程使能Vsync信号
整个步骤二,其实是根据传入的vsyncSource,指导对应的监听者是来自APP,然后创建一对socket连接,来进行进程间的通信。
我们继续回到主线进行跟踪处理
DisplayEventReceiver::DisplayEventReceiver(ISurfaceComposer::VsyncSource vsyncSource,
ISurfaceComposer::ConfigChanged configChanged) {
//方法1 获取SurfaceFling服务,并保存在ComposerService中
sp sf(ComposerService::getComposerService());
if (sf != nullptr) {
//方法2 通过binder,最后跨进程调用surfaceFling的createDisplayEventConnection方法
//方法位置 ISurfaceComposer.cpp frameworks\native\libs\gui
mEventConnection = sf->createDisplayEventConnection(vsyncSource, configChanged);
if (mEventConnection != nullptr) {
//方法3 获取方法二中创建的gui::BitTube对象
mDataChannel = std::make_uniquegui::BitTube();
//方法4
mEventConnection->stealReceiveChannel(mDataChannel.get());
}
}
}
方法3是获取了对应的gui::BitTube对象。我们主要来分析一下方法四。
方法四调用了EventThreadConnect的stealReceiveChannel
status_t EventThreadConnection::stealReceiveChannel(gui::BitTube* outChannel) {
outChannel->setReceiveFd(mChannel.moveReceiveFd());
return NO_ERROR;
}
这的mChannel是gui::BitTube。这里将事件连接器EventThreadConnection中创建的Fd复制给了outChannel。也就是DisplayEventReceiver的mDataChannel。
所以这时候app进程就有了mReceivedFd,surfaceFlinger进程有了mSendFd。这时候通过socket就能够进行通信了。
整个DisplayEventReceiver的作用是创建一个socket以及对应的文件,然后实现和SurfaceFlinger的双向通讯。
这里我们为止,我们只是创建NativeDisplayEventReceiver。
那么后续还有
receiver->initialize()
status_t DisplayEventDispatcher::initialize() {
//异常检测
status_t result = mReceiver.initCheck();
if (result) {
ALOGW(“Failed to initialize display event receiver, status=%d”, result);
return result;
}
//这里的Looper就是应用app进程的主线程Looper,这一步就是将创建的BitTube信道的
//fd添加到Looper的监听。
int rc = mLooper->addFd(mReceiver.getFd(), 0, Looper::EVENT_INPUT,
this, NULL);
if (rc < 0) {
return UNKNOWN_ERROR;
}
return OK;
}
这里之所以能够加入到监听,是因为我们的
这里整个方法比较简单,就是进行异常的检测,让后将在步骤一中创建的fd文件加入到Looper的监听中。
到这里为止,整个流程算是打通了。
java层通过DisplayEventReceive的nativeInit函数,创建了应用层和SurfaceFlinger的连接,通过一对socket,对应mReceiveFd和mSendFd,应用层通过native层Looper将mReceiveFd加入监听,等待mSendFd的写入。
那么mSendFd什么时候写入,又是如何传递到应用层的呢?
当我们进行页面刷新绘制的时候,看一下如何注册对于Vsync的监听的
@UnsupportedAppUsage
void scheduleTraversals() {
…
mChoreographer.postCallback(Choreographer.CALLBACK_TRAVERSAL, mTraversalRunnable, null);
…
}
public void postCallback(int callbackType, Runnable action, Object token) {
postCallbackDelayed(callbackType, action, token, 0);
}
public void postCallbackDelayed(int callbackType,Runnable action, Object token, long delayMillis) {
postCallbackDelayedInternal(callbackType, action, token, delayMillis);
}
private void postCallbackDelayedInternal(int callbackType,Object action, Object token, long delayMillis) {
…
//需要立即进行绘制
scheduleFrameLocked(now);
…
}
private void scheduleFrameLocked(long now) {
…
scheduleVsyncLocked();
…
}
private void scheduleVsyncLocked() {
//执行同步功能,进行一次绘制。这里会进行一个VSYNC事件的监听注册,如果有有
mDisplayEventReceiver.scheduleVsync();
}
public void scheduleVsync() {
…
nativeScheduleVsync(mReceiverPtr);
…
}
这里的**nativeScheduleVsync()**就是应用层向native层注册监听下一次Vsync信号的方法。
nativeScheduleVsync
//base\core\jni\android_view_DisplayEventReceiver.cpp 8492 2020/9/14 96
static void nativeScheduleVsync(JNIEnv* env, jclass clazz, jlong receiverPtr) {
sp receiver =
reinterpret_cast<NativeDisplayEventReceiver*>(receiverPtr);
//调用Recivier的调度方法
status_t status = receiver->scheduleVsync();
}
这里的receiver,是NativeDisplayEventReceiver。而NativeDisplayEventReceiver是继承自DisplayEventDispatcher
DisplayEventDispatcher->scheduleVsync();
//调度Vsync
status_t DisplayEventDispatcher::scheduleVsync() {
//如果当前正在等待Vsync信号,那么直接返回
if (!mWaitingForVsync) {
nsecs_t vsyncTimestamp;
PhysicalDisplayId vsyncDisplayId;
uint32_t vsyncCount;
//重点方法1 处理对应的准备事件,如果获取到了Vsync信号的话,这里会返回true
if (processPendingEvents(&vsyncTimestamp, &vsyncDisplayId, &vsyncCount)) {
ALOGE(“dispatcher %p ~ last event processed while scheduling was for %” PRId64 “”,
this, ns2ms(static_cast<nsecs_t>(vsyncTimestamp)));
}
//重点方法2 请求下一个Vsync信号
status_t status = mReceiver.requestNextVsync();
…
//设置正在等待Vsync信号
mWaitingForVsync = true;
}
return OK;
}
这里我们跟踪一下方法1
DisplayEventDispatcher::processPendingEvents
bool DisplayEventDispatcher::processPendingEvents(
nsecs_t* outTimestamp, PhysicalDisplayId* outDisplayId, uint32_t* outCount) {
bool gotVsync = false;
DisplayEventReceiver::Event buf[EVENT_BUFFER_SIZE];
ssize_t n;
//获取对应的事件
while ((n = mReceiver.getEvents(buf, EVENT_BUFFER_SIZE)) > 0) {
ALOGV(“dispatcher %p ~ Read %d events.”, this, int(n));
for (ssize_t i = 0; i < n; i++) {
const DisplayEventReceiver::Event& ev = buf[i];
switch (ev.header.type) {
case DisplayEventReceiver::DISPLAY_EVENT_VSYNC://Vsync类型
//获取到最新的Vsync信号,然后将时间戳等信息保存下来
gotVsync = true;
*outTimestamp = ev.header.timestamp;
*outDisplayId = ev.header.displayId;
*outCount = ev.vsync.count;
break;
…
return gotVsync;
}
会通过getEvents方法获取到对应的事件类型,然后返回是否为Vsync信号。
DisplayEventReceiver::getEvents
// native\libs\gui\DisplayEventReceiver.cpp
ssize_t DisplayEventReceiver::getEvents(DisplayEventReceiver::Event* events,size_t count) {
//这里的mDataChannel是在init中创建的,用来接收Vsync信号
return DisplayEventReceiver::getEvents(mDataChannel.get(), events, count);
}
ssize_t DisplayEventReceiver::getEvents(gui::BitTube* dataChannel,
Event* events, size_t count)
{
return gui::BitTube::recvObjects(dataChannel, events, count);
}
//native\libs\gui\BitTube.cpp
static ssize_t recvObjects(BitTube* tube, T* events, size_t count) {
return recvObjects(tube, events, count, sizeof(T));
}
ssize_t BitTube::recvObjects(BitTube* tube, void* events, size_t count, size_t objSize) {
char* vaddr = reinterpret_cast<char*>(events);
//通过socket读取数据
ssize_t size = tube->read(vaddr, count * objSize);
return size < 0 ? size : size / static_cast<ssize_t>(objSize);
}
//读取数据
ssize_t BitTube::read(void* vaddr, size_t size) {
ssize_t err, len;
do {
//将mReceiveFd接收到的数据,放入到size大小的vaddr缓冲区。并返回实际接收到的数据大小len
len = ::recv(mReceiveFd, vaddr, size, MSG_DONTWAIT);
err = len < 0 ? errno : 0;
} while (err == EINTR);
if (err == EAGAIN || err == EWOULDBLOCK) {
//如果接收出现异常,返回0
return 0;
}
return err == 0 ? len : -err;
}
这里将接收到的数据放入到对应的缓冲区,并返回数据之后,会校验返回的具体的数据类型。
status_t DisplayEventReceiver::requestNextVsync() {
//校验当前连接存在
if (mEventConnection != nullptr) {
//通过连接请求下一个Vsync信号。这个mEventConnection。是在DisplayEventReceiver初始化的时候创建的
//具体的是EventThreadConnection(位于EventThread中)
mEventConnection->requestNextVsync();
return NO_ERROR;
}
return NO_INIT;
}
void EventThreadConnection::requestNextVsync() {
ATRACE_NAME(“requestNextVsync”);
mEventThread->requestNextVsync(this);
}
void EventThread::requestNextVsync(const sp& connection) {
if (connection->resyncCallback) {
connection->resyncCallback();
}
//线程锁机制
std::lock_guardstd::mutex lock(mMutex);
//vsyncRequest默认值是None.定义在EventThread.h文件中
if (connection->vsyncRequest == VSyncRequest::None) {
//之所以Vsync是一次性的,是因为,当我们当前是None之后,会将这个字段设置为Single。
//后续硬件再有Vsync信号过来的时候,不会再执行这个方法
connection->vsyncRequest = VSyncRequest::Single;
mCondition.notify_all();
}
}
这里当有Vsync的信号过来的时候,会调用一个notify_all()。这个方法会唤醒所有执行了**wait()**方法的线程。
那么这个到底会唤醒谁呢?
这里就不得不说一下EventThread创建过程中了。
EventThread::EventThread(VSyncSource* src, std::unique_ptr uniqueSrc,
InterceptVSyncsCallback interceptVSyncsCallback, const char* threadName)
: mVSyncSource(src),
mVSyncSourceUnique(std::move(uniqueSrc)),
mInterceptVSyncsCallback(std::move(interceptVSyncsCallback)),
mThreadName(threadName) {
…
//创建了mThread线程
mThread = std::thread(this NO_THREAD_SAFETY_ANALYSIS {
std::unique_lockstd::mutex lock(mMutex);
//创建线程的时候调用了threadMain函数
threadMain(lock);
});
…
}
在EventThread创建时,会创建一个线程,然后调用threadMain方法。
//在创建EventThread的时候会调用该方法。会不断的遍历
void EventThread::threadMain(std::unique_lockstd::mutex& lock) {
DisplayEventConsumers consumers;
//只要没有退出,则一直遍历循环
while (mState != State::Quit) {
std::optionalDisplayEventReceiver::Event event;
…
//是否有Vsync请求
bool vsyncRequested = false;
…
//查询所有的连接,其实这里一个连接就是一个监听
auto it = mDisplayEventConnections.begin();
while (it != mDisplayEventConnections.end()) {
if (const auto connection = it->promote()) {
vsyncRequested |= connection->vsyncRequest != VSyncRequest::None;
//遍历,将需要通知的监听放入到consumers中
if (event && shouldConsumeEvent(*event, connection)) {
consumers.push_back(connection);
}
++it;
} else {
it = mDisplayEventConnections.erase(it);
}
}
if (!consumers.empty()) {
//进行事件的分发。最终会调用gui::BitTube::sendObjects函数
dispatchEvent(*event, consumers);
consumers.clear();
}
State nextState;
if (mVSyncState && vsyncRequested) {
nextState = mVSyncState->synthetic ? State::SyntheticVSync : State::VSync;
} else {
ALOGW_IF(!mVSyncState, “Ignoring VSYNC request while display is disconnected”);
nextState = State::Idle;
}
if (mState != nextState) {
if (mState == State::VSync) {
mVSyncSource->setVSyncEnabled(false);
} else if (nextState == State::VSync) {
mVSyncSource->setVSyncEnabled(true);
}
mState = nextState;
}
if (event) {
continue;
}
//空闲状态,则等待事件请求
if (mState == State::Idle) {
mCondition.wait(lock);
} else {
…
}
}
}
threadMain函数会不断的循环。如果找到了能够消耗事件的EventThreadConnection,则调用dispatchEvent分发事件。如果当前为空闲状态,则会让线程进入到等待,等待唤醒。
也就是我们在前面所说的唤醒。
当有Vsync信号到来的时候,会调用dispatchEvent方法进行分发
void EventThread::dispatchEvent(const DisplayEventReceiver::Event& event,
const DisplayEventConsumers& consumers) {
//这里的DisplayEventConsumers是vector,内部保存的是EventThreadConnection。
for (const auto& consumer : consumers) {
switch (consumer->postEvent(event)) {
case NO_ERROR:
break;
case -EAGAIN:
ALOGW(“Failed dispatching %s for %s”, toString(event).c_str(),
toString(*consumer).c_str());
break;
default:
// Treat EPIPE and other errors as fatal.
removeDisplayEventConnectionLocked(consumer);
}
}
}
我们看一下postEvent方法
//EventThread.cpp frameworks\native\services\surfaceflinger\Scheduler
status_t EventThreadConnection::postEvent(const DisplayEventReceiver::Event& event) {
ssize_t size = DisplayEventReceiver::sendEvents(&mChannel, &event, 1);
return size < 0 ? status_t(size) : status_t(NO_ERROR);
}
//DisplayEventReceiver.cpp frameworks\native\libs\gui
ssize_t DisplayEventReceiver::sendEvents(gui::BitTube* dataChannel,
Event const* events, size_t count)
{
return gui::BitTube::sendObjects(dataChannel, events, count);
}
ssize_t DisplayEventReceiver::sendEvents(gui::BitTube* dataChannel,
Event const* events, size_t count)
{
//这里会发送Vsync信号,往BitTube所对应的
return gui::BitTube::sendObjects(dataChannel, events, count);
}
//BitTube.h frameworks\native\libs\gui\include\private\gui
static ssize_t sendObjects(BitTube* tube, T const* events, size_t count) {
return sendObjects(tube, events, count, sizeof(T));
}
ssize_t BitTube::sendObjects(BitTube* tube, void const* events, size_t count, size_t objSize) {
const char* vaddr = reinterpret_cast<const char*>(events);
//往vaddr中写数据。当mSendFd写入文件以后以后,与之对应的mReceiveFd则能接收到数据。
//然后mReceiveFd则会调用对应的回调函数
ssize_t size = tube->write(vaddr, count * objSize);
…
return size < 0 ? size : size / static_cast<ssize_t>(objSize);
}
当sendObjects像mSendFd写入数据以后,mReceiveFd能够接收到消息。而在nativeInit过程中,会将mReceiveFd添加到handler的epoll进行监听。所以当写入数据以后,就会回调对应的handleEvent回调函数。而这个回调在添加mReceiveFd的时候,是一起注册的
回调流程
//mReceiveFd能接收到对应写入的数据,然后调用此方法。
int DisplayEventDispatcher::handleEvent(int, int events, void*) {
if (events & (Looper::EVENT_ERROR | Looper::EVENT_HANGUP)) {
ALOGE("Display event receiver pipe was closed or an error occurred. "
“events=0x%x”, events);
return 0; // remove the callback
}
nsecs_t vsyncTimestamp;
PhysicalDisplayId vsyncDisplayId;
uint32_t vsyncCount;
if (processPendingEvents(&vsyncTimestamp, &vsyncDisplayId, &vsyncCount)) {
ALOGV(“dispatcher %p ~ Vsync pulse: timestamp=%” PRId64 “, displayId=%”
ANDROID_PHYSICAL_DISPLAY_ID_FORMAT “, count=%d”,
this, ns2ms(vsyncTimestamp), vsyncDisplayId, vsyncCount);
//这里已经获取到一个Vsync信息,所以将正在等待Vsync标志位置为false。
mWaitingForVsync = false;
自我介绍一下,小编13年上海交大毕业,曾经在小公司待过,也去过华为、OPPO等大厂,18年进入阿里一直到现在。
深知大多数初中级Android工程师,想要提升技能,往往是自己摸索成长或者是报班学习,但对于培训机构动则近万的学费,着实压力不小。自己不成体系的自学效果低效又漫长,而且极易碰到天花板技术停滞不前!
因此收集整理了一份《2024年Android移动开发全套学习资料》,初衷也很简单,就是希望能够帮助到想自学提升又不知道该从何学起的朋友,同时减轻大家的负担。
既有适合小白学习的零基础资料,也有适合3年以上经验的小伙伴深入学习提升的进阶课程,基本涵盖了95%以上Android开发知识点,真正体系化!
由于文件比较大,这里只是将部分目录截图出来,每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频,并且会持续更新!
如果你觉得这些内容对你有帮助,可以扫码获取!!(备注:Android)
![](https://i-blog.csdnimg.cn/blog_migrate/0df31f0ba4a96cfc49f98a8ac65a6c05.jpeg)
建议
当我们出去找工作,或者准备找工作的时候,我们一定要想,我面试的目标是什么,我自己的技术栈有哪些,近期能掌握的有哪些,我的哪些短板 ,列出来,有计划的去完成,别看前两天掘金一些大佬在驳来驳去 ,他们的观点是他们的,不要因为他们的观点,膨胀了自己,影响自己的学习节奏。基础很大程度决定你自己技术层次的厚度,你再熟练框架也好,也会比你便宜的,性价比高的替代,很现实的问题但也要有危机意识,当我们年级大了,有哪些亮点,与比我们经历更旺盛的年轻小工程师,竞争。
-
无论你现在水平怎么样一定要 持续学习 没有鸡汤,别人看起来的毫不费力,其实费了很大力,这四个字就是我的建议!!!!!!!!!
-
准备想说怎么样写简历,想象算了,我觉得,技术就是你最好的简历
-
我希望每一个努力生活的it工程师,都会得到自己想要的,因为我们很辛苦,我们应得的。
-
有什么问题想交流,欢迎给我私信,欢迎评论
【附】相关架构及资料
内含往期Android高级架构资料、源码、笔记、视频。高级UI、性能优化、架构师课程、NDK、混合式开发(ReactNative+Weex)微信小程序、Flutter全方面的Android进阶实践技术
《Android学习笔记总结+移动架构视频+大厂面试真题+项目实战源码》,点击传送门即可获取!
,膨胀了自己,影响自己的学习节奏。基础很大程度决定你自己技术层次的厚度,你再熟练框架也好,也会比你便宜的,性价比高的替代,很现实的问题但也要有危机意识,当我们年级大了,有哪些亮点,与比我们经历更旺盛的年轻小工程师,竞争。
-
无论你现在水平怎么样一定要 持续学习 没有鸡汤,别人看起来的毫不费力,其实费了很大力,这四个字就是我的建议!!!!!!!!!
-
准备想说怎么样写简历,想象算了,我觉得,技术就是你最好的简历
-
我希望每一个努力生活的it工程师,都会得到自己想要的,因为我们很辛苦,我们应得的。
-
有什么问题想交流,欢迎给我私信,欢迎评论
【附】相关架构及资料
[外链图片转存中…(img-L3hgm3fU-1712468694882)]
[外链图片转存中…(img-NfMpSSAI-1712468694882)]
内含往期Android高级架构资料、源码、笔记、视频。高级UI、性能优化、架构师课程、NDK、混合式开发(ReactNative+Weex)微信小程序、Flutter全方面的Android进阶实践技术