Android输入系统IMS（5）--ims分发到java层

最新推荐文章于 2024-08-28 02:19:46 发布
最新推荐文章于 2024-08-28 02:19:46 发布
阅读量667 收藏 2
点赞数 3
分类专栏： Android系统 文章标签： Android输入系统 Android IMS
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/longruic/article/details/90764007
版权

1.addWindow函数（InputChannel创建注册）：

    通过上一篇的分析，我们发现InputDispatcherThread调用InputChannel的sendMessage函数发送了一条消息，但是我们不知道谁在接收这条输入事件消息。在这里提前告诉大家是APP在接收这些消息。这篇我们将讲解消息到底是怎么发送到app的。

status_t InputChannel::sendMessage(const InputMessage* msg) {
    size_t msgLength = msg->size();
    ssize_t nWrite;
    do {
//最终通过socketpair发送出去，根据之前带代码可以知道是通过wms发给app了。
        nWrite = ::send(mFd, msg, msgLength, MSG_DONTWAIT | MSG_NOSIGNAL);
    } while (nWrite == -1 && errno == EINTR);
 
}

   有发送就一定有接收以及初始化函数这样很自然就会关注到：InputChannel::openInputChannelPair函数.通过搜索代码关键字可以得到如下的函数关系图：

   app都是带Activity的，调用startActivity(Intent), 会通过Binder IPC机制, 最终调用到ActivityThread中的handleLaunchActivity方法开始分析,下图的流程显示了启动过程中的函数调用关系：

根据上面的的分析可以从 addWindow（）函数入手分析调用过程。

    根据这个时序图可以看出WindowManagerService.java中 给addWindow函数传入了outInputChannel变量对象。使用InputChannel.openInputChannelPair(name);在native层创建的  InputChannel[] inputChannels会调用mInputManager.registerInputChannel函数 -> com_android_server_input_InputManagerService.cpp    中的static void nativeRegisterInputChannel -> InputDispatcher::registerInputChannel注册到native c++层。InputDispatcher要能够发送事件数据，必须的要让其知道对应的window的InputChannel，这个通过注册实现的。同时调用inputChannels[1].transferTo(outInputChannel);把native其中的一个inputChannels[1]转换到java层的outInputChannel，包含socketpair文件句柄。（outInputChannel是在app启动过程中java层NEW出来的后面会分析）

status_t InputDispatcher::registerInputChannel(const sp<InputChannel>& inputChannel,
        const sp<InputWindowHandle>& inputWindowHandle, bool monitor) {
#if DEBUG_REGISTRATION
    ALOGD("channel '%s' ~ registerInputChannel - monitor=%s", inputChannel->getName().string(),
            toString(monitor));
#endif

    { // acquire lock
        AutoMutex _l(mLock);

        if (getConnectionIndexLocked(inputChannel) >= 0) {
            ALOGW("Attempted to register already registered input channel '%s'",
                    inputChannel->getName().string());
            return BAD_VALUE;
        }
       //这个将inputWindowHandle对应的inputChannel封装为Connection
        sp<Connection> connection = new Connection(inputChannel, inputWindowHandle, monitor);
        //这个就是unix socket文件句柄
        int fd = inputChannel->getFd();
       //将connection保存到映射表中
        mConnectionsByFd.add(fd, connection);

        if (monitor) {
            mMonitoringChannels.push(inputChannel);
        }

        mLooper->addFd(fd, 0, ALOOPER_EVENT_INPUT, handleReceiveCallback, this);
    } // release lock

    // Wake the looper because some connections have changed.
    mLooper->wake();
    return OK;
}

上面这段代码中的fd网络文件句柄和connection是通信发送事件的关键；上一篇我们已经分析分发过程了：其中部分代码：

void InputDispatcher::startDispatchCycleLocked(nsecs_t currentTime,
        const sp<Connection>& connection) {
 
 DispatchEntry* dispatchEntry = connection->outboundQueue.head;
 case EventEntry::TYPE_KEY: {
            KeyEntry* keyEntry = static_cast<KeyEntry*>(eventEntry);
 
            // Publish the key event.
            status = connection->inputPublisher.publishKeyEvent(dispatchEntry->seq,
                    keyEntry->deviceId, keyEntry->source,
                    dispatchEntry->resolvedAction, dispatchEntry->resolvedFlags,
                    keyEntry->keyCode, keyEntry->scanCode,
                    keyEntry->metaState, keyEntry->repeatCount, keyEntry->downTime,
                    keyEntry->eventTime);
            break;
}

可以看到操作的都是connection对象，可以总结一下：上一篇分析的InputChannel::sendMessage方式输入事件到目前为止是发送到了WindowManagerService.java中使用InputChannel.openInputChannelPair(name);创建的  InputChannel[] inputChannels.其中的inputChannels[1]转换到java层的outInputChannel。

 

2. app启动过程如何触发addWindow函数执行的：

///
final void handleResumeActivity(IBinder token,
        boolean clearHide, boolean isForward, boolean reallyResume) {
			
	        // TODO Push resumeArgs into the activity for consideration
            ActivityClientRecord r = performResumeActivity(token, clearHide);
		
            if (r.window == null && !a.mFinished && willBeVisible) {
                r.window = r.activity.getWindow();
                View decor = r.window.getDecorView();
                decor.setVisibility(View.INVISIBLE);
                ViewManager wm = a.getWindowManager();
                WindowManager.LayoutParams l = r.window.getAttributes();
                a.mDecor = decor;
                l.type = WindowManager.LayoutParams.TYPE_BASE_APPLICATION;
                l.softInputMode |= forwardBit;
                if (a.mVisibleFromClient) {
                    a.mWindowAdded = true;
                    wm.addView(decor, l);//decor是view类,wm是个ViewManager接口
                }

            // If the window has already been added, but during resume
            // we started another activity, then don't yet make the
            // window visible.
            } else if (!willBeVisible) {
                if (localLOGV) Slog.v(
                    TAG, "Launch " + r + " mStartedActivity set");
                r.hideForNow = true;
            }
	
}		
public interface ViewManager//接口
{
    public void addView(View view, ViewGroup.LayoutParams params);
    public void updateViewLayout(View view, ViewGroup.LayoutParams params);
    public void removeView(View view);
}
public interface WindowManager extends ViewManager {
}

WindowManagerImpl.java
public final class WindowManagerImpl implements WindowManager {

 private final WindowManagerGlobal mGlobal = WindowManagerGlobal.getInstance();
    private final Display mDisplay;
    private final Window mParentWindow;
	
    @Override
    public void addView(View view, ViewGroup.LayoutParams params) {
        mGlobal.addView(view, params, mDisplay, mParentWindow);
    }

}	
WindowManagerGlobal.java
 public void addView(View view, ViewGroup.LayoutParams params,
            Display display, Window parentWindow) {

			root = new ViewRootImpl(view.getContext(), display);

            view.setLayoutParams(wparams);

            mViews.add(view);
            mRoots.add(root);
            mParams.add(wparams);
			root.setView(view, wparams, panelParentView);//root是ViewRootImpl类
}				
ViewRootImpl.java
public final class ViewRootImpl implements ViewParent,
        View.AttachInfo.Callbacks, HardwareRenderer.HardwareDrawCallbacks {
		final IWindowSession mWindowSession;	
	    public void setView(View view, WindowManager.LayoutParams attrs, View panelParentView) {

			    // Schedule the first layout -before- adding to the window
                // manager, to make sure we do the relayout before receiving
                // any other events from the system.
                requestLayout();
                if ((mWindowAttributes.inputFeatures
                        & WindowManager.LayoutParams.INPUT_FEATURE_NO_INPUT_CHANNEL) == 0) {
                    mInputChannel = new InputChannel();//第一次需要创建InputChannel导致native层创建socketpair
                }
				
				res = mWindowSession.addToDisplay(mWindow, mSeq, mWindowAttributes,
                            getHostVisibility(), mDisplay.getDisplayId(),
                            mAttachInfo.mContentInsets, mInputChannel);
		
		}
}
//通过AIDL跨进程通信机制最终调用到WindowManagerService的addWindow();
//IWindowSession.aidl
interface IWindowSession {
    int addToDisplay(IWindow window, int seq, in WindowManager.LayoutParams attrs,
            in int viewVisibility, in int layerStackId, out Rect outContentInsets,
            out InputChannel outInputChannel);
}		
	
// ./common/obj/JAVA_LIBRARIES/framework_intermediates/src/core/java/android/view/IWindowSession.java

@Override public int addToDisplay(android.view.IWindow window, int seq, android.view.WindowManager.LayoutParams attrs, int viewVisibility, int layerStackId, android.graphics.Rect outContentInsets, android.view.InputChannel outInputChannel) throws android.os.RemoteException
{
mRemote.transact(Stub.TRANSACTION_addToDisplay, _data, _reply, 0);
}	
	
	
// framework/base/services/core/java/com/android/server/wm/Session.java.
final class Session extends IWindowSession.Stub
        implements IBinder.DeathRecipient {
	final WindowManagerService mService;
    @Override
    public int addToDisplay(IWindow window, int seq, WindowManager.LayoutParams attrs,
            int viewVisibility, int displayId, Rect outContentInsets,
            InputChannel outInputChannel) {
        return mService.addWindow(this, window, seq, attrs, viewVisibility, displayId,
                outContentInsets, outInputChannel);
    }	
}

// WindowManagerService.java
    public int addWindow(Session session, IWindow client, int seq,
            WindowManager.LayoutParams attrs, int viewVisibility, int displayId,
            Rect outContentInsets, InputChannel outInputChannel) {
}

    通过上的关键代码可以看到使用了接口，继承，AIDL跨进程通信机制，handleResumeActivity函数最终是触发了WindowManagerService.java的 public int addWindow函数的调用。

3.APP启动创建的 InputChannel监听器初始化：

ViewRootImpl.java
public final class ViewRootImpl implements ViewParent,
        View.AttachInfo.Callbacks, HardwareRenderer.HardwareDrawCallbacks {
		final IWindowSession mWindowSession;	
	    public void setView(View view, WindowManager.LayoutParams attrs, View panelParentView) {
                if (mInputChannel != null) {//mInputChannel 指向native层创建的inputChannels[1]
                    if (mInputQueueCallback != null) {
                        mInputQueue = new InputQueue();
                        mInputQueueCallback.onInputQueueCreated(mInputQueue);
                    }
					//为InputChannel注册监听器
                    mInputEventReceiver = new WindowInputEventReceiver(mInputChannel,
                            Looper.myLooper());
                }		
				
    final class WindowInputEventReceiver extends InputEventReceiver {
        public WindowInputEventReceiver(InputChannel inputChannel, Looper looper) {
            super(inputChannel, looper);
        }

        @Override
        public void onInputEvent(InputEvent event) {
            enqueueInputEvent(event, this, 0, true);
        }

        @Override
        public void onBatchedInputEventPending() {
            if (mUnbufferedInputDispatch) {
                super.onBatchedInputEventPending();
            } else {
                scheduleConsumeBatchedInput();
            }
        }

        @Override
        public void dispose() {
            unscheduleConsumeBatchedInput();
            super.dispose();
        }
    }
    WindowInputEventReceiver mInputEventReceiver;	
	
InputEventReceiver.java
public abstract class InputEventReceiver {

	    public InputEventReceiver(InputChannel inputChannel, Looper looper) {
			mInputChannel = inputChannel;
			mMessageQueue = looper.getQueue();
			mReceiverPtr = nativeInit(new WeakReference<InputEventReceiver>(this),
					inputChannel, mMessageQueue);

			mCloseGuard.open("dispose");
    }

}	
android_view_InputEventReceiver.cpp
static jlong nativeInit(JNIEnv* env, jclass clazz, jobject receiverWeak,
        jobject inputChannelObj, jobject messageQueueObj) {
   //通过inputChannelObj 获取native层的InputChannel
    sp<InputChannel> inputChannel = android_view_InputChannel_getInputChannel(env,
            inputChannelObj);
    //获取java层InputEventReceiver对象的native层的消息队列
    sp<MessageQueue> messageQueue = android_os_MessageQueue_getMessageQueue(env, messageQueueObj);
    //使用inputChannel和messageQueue创建native对应的InputEventReceiver对象
    sp<NativeInputEventReceiver> receiver = new NativeInputEventReceiver(env,
            receiverWeak, inputChannel, messageQueue);
    status_t status = receiver->initialize();
    if (status) {
        String8 message;
        message.appendFormat("Failed to initialize input event receiver.  status=%d", status);
        jniThrowRuntimeException(env, message.string());
        return 0;
    }

    receiver->incStrong(gInputEventReceiverClassInfo.clazz); // retain a reference for the object
    return reinterpret_cast<jlong>(receiver.get());
}
status_t NativeInputEventReceiver::initialize() {
    setFdEvents(ALOOPER_EVENT_INPUT);
    return OK;
}
void NativeInputEventReceiver::setFdEvents(int events) {
    if (mFdEvents != events) {
        mFdEvents = events;
        int fd = mInputConsumer.getChannel()->getFd();
        if (events) {
			//用looper监听inputChannel对应的socketpair文件句柄
            mMessageQueue->getLooper()->addFd(fd, 0, events, this, NULL);
        } else {
            mMessageQueue->getLooper()->removeFd(fd);
        }
    }
}


int Looper::addFd(int fd, int ident, int events, ALooper_callbackFunc callback, void* data) {
    return addFd(fd, ident, events, callback ? new SimpleLooperCallback(callback) : NULL, data);
}
 
int Looper::addFd(int fd, int ident, int events, const sp<loopercallback>& callback, void* data) {
    { // acquire lock
        AutoMutex _l(mLock);
        Request request;
        request.fd = fd;
        request.ident = ident;
        //这个很重要，当被监听的文件发生变化时就会调用该callback函数
        request.callback = callback;
        request.data = data;
 
        ssize_t requestIndex = mRequests.indexOfKey(fd);
        if (requestIndex < 0) {
            int epollResult = epoll_ctl(mEpollFd, EPOLL_CTL_ADD, fd, & eventItem);
            mRequests.add(fd, request);
        }
    } // release lock
    return 1;
}

     通过上面的关键代码分析，这段代码完成了epoll对 “WindowManagerService.java中使用InputChannel.openInputChannelPair(name);创建的  InputChannel[] inputChannels.其中的inputChannels[1]转换到java层的outInputChannel"完成了监听初始化动作。下面看看是如何监听有可读 数据接收的。

4.APP端的InputChannel中的事件接收

int Looper::pollOnce(int timeoutMillis, int* outFd, int* outEvents, void** outData) {
    int result = 0;
    for (;;) {
        while (mResponseIndex < mResponses.size()) {
            const Response& response = mResponses.itemAt(mResponseIndex++);
            int ident = response.request.ident;
            if (ident >= 0) {
                int fd = response.request.fd;
                int events = response.events;
                void* data = response.request.data;
                if (outFd != NULL) *outFd = fd;
                if (outEvents != NULL) *outEvents = events;
                if (outData != NULL) *outData = data;
                return ident;
            }
        }
        result = pollInner(timeoutMillis);
    }
}
 
int Looper::pollInner(int timeoutMillis) {
    struct epoll_event eventItems[EPOLL_MAX_EVENTS];
    //睡眠等待消息
    int eventCount = epoll_wait(mEpollFd, eventItems, EPOLL_MAX_EVENTS, timeoutMillis);
    for (int i = 0; i < eventCount; i++) {
        int fd = eventItems[i].data.fd;
        uint32_t epollEvents = eventItems[i].events;
        if (fd == mWakeReadPipeFd) {
            if (epollEvents & EPOLLIN) {
                awoken();
            }
        } else {
            ssize_t requestIndex = mRequests.indexOfKey(fd);
            if (requestIndex >= 0) {
                int events = 0;
                if (epollEvents & EPOLLIN) events |= ALOOPER_EVENT_INPUT;
                if (epollEvents & EPOLLOUT) events |= ALOOPER_EVENT_OUTPUT;
                if (epollEvents & EPOLLERR) events |= ALOOPER_EVENT_ERROR;
                if (epollEvents & EPOLLHUP) events |= ALOOPER_EVENT_HANGUP;
                //将输入事件push到队列上
                pushResponse(events, mRequests.valueAt(requestIndex));
            }
        }
    }
Done: ;
    //处理response事件
    for (size_t i = 0; i < mResponses.size(); i++) {
        Response& response = mResponses.editItemAt(i);
        if (response.request.ident == ALOOPER_POLL_CALLBACK) {
            int fd = response.request.fd;
            int events = response.events;
            void* data = response.request.data;
            // 下面的callback就是 NativeInputEventRecieverd
            int callbackResult = response.request.callback->handleEvent(fd, events, data);
            if (callbackResult == 0) {
                removeFd(fd);
            }
            response.request.callback.clear();
            result = ALOOPER_POLL_CALLBACK;
        }
    }
    return result;
}
 
int NativeInputEventReceiver::handleEvent(int receiveFd, int events, void* data) {
 
if (events & ALOOPER_EVENT_INPUT) {
        JNIEnv* env = AndroidRuntime::getJNIEnv();
        //处理消费事件
        status_t status = consumeEvents(env, false /*consumeBatches*/, -1, NULL);
        mMessageQueue->raiseAndClearException(env, "handleReceiveCallback");
        return status == OK || status == NO_MEMORY ? 1 : 0;
}
    return 1;
}
 
status_t NativeInputEventReceiver::consumeEvents(JNIEnv* env,
        bool consumeBatches, nsecs_t frameTime, bool* outConsumedBatch) {
    for (;;) {
        uint32_t seq;
        InputEvent* inputEvent;
        //从buffer取出事件
        status_t status = mInputConsumer.consume(&mInputEventFactory,
                consumeBatches, frameTime, &seq, &inputEvent);
        if (!skipCallbacks) {
            jobject inputEventObj;
            switch (inputEvent->getType()) {
            case AINPUT_EVENT_TYPE_KEY:
                //转换为java层的InputEvent
                inputEventObj = android_view_KeyEvent_fromNative(env,
                        static_cast<keyevent*>(inputEvent));
                break;
            }
            if (inputEventObj) {
                //会调用到java层的函数InputEventReceiver->dispatchInputEvent
                env->CallVoidMethod(receiverObj.get(),
                        gInputEventReceiverClassInfo.dispatchInputEvent, seq,
 inputEventObj);
            }
        }
    }
}

    再来看看InputEventReceiver.java文件中的：

    // Called from native code.
    @SuppressWarnings("unused")
    private void dispatchInputEvent(int seq, InputEvent event) {
        mSeqMap.put(event.getSequenceNumber(), seq);
        onInputEvent(event);//处理event
    }
    public void onInputEvent(InputEvent event) {
        finishInputEvent(event, false);
    }
    public final void finishInputEvent(InputEvent event, boolean handled) {
        if (event == null) {
            throw new IllegalArgumentException("event must not be null");
        }
        if (mReceiverPtr == 0) {
            Log.w(TAG, "Attempted to finish an input event but the input event "
                    + "receiver has already been disposed.");
        } else {
            int index = mSeqMap.indexOfKey(event.getSequenceNumber());
            if (index < 0) {
                Log.w(TAG, "Attempted to finish an input event that is not in progress.");
            } else {
                int seq = mSeqMap.valueAt(index);
                mSeqMap.removeAt(index);
                nativeFinishInputEvent(mReceiverPtr, seq, handled);
            }
        }
        event.recycleIfNeededAfterDispatch();
    }

    分析到这里，输入事件已经传递到java层了。具体事件怎么分发流动还要看当前app是如何写的，以及是什么按键。输入事件并不是全部被window的view处理了，比如返回键，如果此时系统输入法是显示的处于最上面，back键首先会去关闭输入法，而window的view是接收不到这个键。一般来说对应Global/system按键是systemserver系统进程处理的并且处理完不会发送到app。对于user按键则最终会调用ViewGroup的：

public final boolean dispatch(Callback receiver, DispatcherState state,
        Object target) {
    switch (mAction) {
        case ACTION_DOWN: {
            mFlags &= ~FLAG_START_TRACKING;
            boolean res = receiver.onKeyDown(mKeyCode, this);
            return res;
        }
    }
    return false;
}

 对于按键是系统处理还是app处理可以参考这篇文章：https://blog.csdn.net/qianhaifeng2012/article/details/51737370

 

Windra6
关注
专栏目录
Doubango ims 框架分析之 sip协议栈
RTC hacker
05-24 1万+
本人承接 sip/ims 视频客户端定制开发，提供IMS硬终端solution,支持接入sip软交换,ims核心网，支持 语音，视频，即时通信功能，视频格式支持 h263,h264，mpeg4 软编软解，提供硬件编解码接口对接，支持基于三星 sp5v210，trident, 海斯芯片H264 硬件编解码，提供服务器，有兴趣请联系我。 VOIP行业资讯和技术趋势请参考： www.voip123
Android输入系统（四）输入事件是如何分发到目标窗口的？
Android进阶三部曲 - 刘望舒
04-05 1610
关联系列 解析WindowManager系列 解析WMS系列 深入理解JNI系列 输入系统系列 基于Android 8.1 前言 在Android输入系统（三）InputReader的加工类型和InputDispatcher的分发过程这篇文章中，由于文章篇幅的原因，InputDispatcher的分发过程还有一部分没有讲解，这一部分就是事件分发到目标窗口的过程。 1. 为事件寻找合适的分发目标 ...
Android | 输入系统(IMS)
345丶
01-30 1315
一般情况下很多同学对于点击事件的认识都只存在于从 Activity 开始的，然后从 Window 中进行分发，甚至有些人可能也只知道和这几个方法，对于 View 层的了解都不属性。自从对于应用层面的分发过程了解清楚之后，就一直忍不住想知道只个事件到底是怎么产生的，到底是从哪里来，要往哪里去，具体的派发机制是怎样的。虽然在开发的过程中搞懂应用层面的也就够了，但是在好奇心的驱使下，我还是忍不住的开始了…
android ims框架
最新发布
weixin_41385851的博客
08-28 56
我整理的一些关于【ide】的项目学习资料（附讲解～～）和大家一起分享、学习一下：https://d.51cto.com/f2PFnNAndroid IMS框架初学者入门指南 在开发Android应用时，IMS（IP Multimedia Subsystem）框架是一个重要的组成部分，尤其是在处理多媒体通信时。对于刚入行的...
Android输入系统IMS（3）--ims启动过程以及读取数据
crl6的博客
05-19 863
艳阳高照的天气适合在出租屋做技术宅~~ 一. InputManagerService的启动: 1.在Android的SystemServer中的private void startOtherServices() {}函数中会启动InputManagerService，以及InputManagerService服务（这个服务后面会用于和InputChannel打交道获取输入事件分发给指定...
android下面的IMS代码
06-14
android下面的IMS代码，是java，很简单，易懂
Android输入系统（二）IMS的启动过程和输入事件的处理
Android进阶三部曲 - 刘望舒
02-07 1635
关联系列 解析WMS系列 深入理解JNI系列 输入系统系列 基于Android 8.1 前言 在上一篇文章中，我们学习了IMS的诞生（创建），IMS创建后还会进行启动，这篇文章我们来学习IMS的启动过程和输入事件的处理。 1.IMS的启动过程 IMS的创建在SystemServer的startOtherServices方法中，不了解请查看Android输入系统（一）输入事件传递流程和InputM...
Android输入系统（三）InputReader的加工类型和InputDispatcher的分发过程
Android进阶三部曲 - 刘望舒
03-14 1196
关联系列 解析WMS系列 深入理解JNI系列 输入系统系列 前言 在上一篇文章中，我们学习了输入事件的处理，输入事件会交由InputDispatcher进行分发，那么InputDispatcher是如何进行分发的？这篇文章会给你答案。 1.InputReader的加工类型 在Android输入系统（二）IMS的启动过程和输入事件的处理这篇文章中，我们知道InputReader会对原始输入事件进行...
Android 事件传递流程 - 基于WMS、IMS、ViewRootImpl等学习笔记
json_it的博客
09-14 1555
概述 在Android中，Touch事件的分发分服务端和应用端。在服务端由WindowManagerService（借助InputManagerService）负责采集和分发的，在应用端则是由ViewRootImpl（内部有一个mView变量指向View树的根，负责控制View树的UI绘制和事件消息的分发）负责分发的。 WMS在启动之后，经过逐层的调用，在Native层启动两个线程：Input...
Android输入系统（一）输入事件传递流程和InputManagerService的诞生
Android进阶三部曲 - 刘望舒
12-07 2284
关联系列 解析WMS系列 View体系系列 前言 很多同学可能会认为输入系统是不是和View的事件分发有些关联，确实是有些关联，只不过View事件分发只能算是输入系统事件传递的一部分。这个系列讲的输入系统主要是我们不常接触的，但还是需要去了解的那部分。 1. 输入事件传递流程的组成部分 输入系统是外界与Android设备交互的基础，仅凭输入系统是无法完成输入事件传递的，因此需要输入系统和Andro...
android下IMS或SIP通信框架
06-17
Android NGN是一个堆栈的NGN（下一代网络）为Android 2（或之后）设备协议栈。 堆栈是基于doubango框架。doubango是世界上最先进的开放源码3GPP IMS／RCS为嵌入式和桌面系统框架。 目前这个版本已经简单修改,去掉了3g或者WIFI检测，支持以太网直接使用。
Android IMS 简要流程
谈谈1974
09-17 8111
文章目录1. IMS 启动1.1 IMS 开关流程1.2 需注意的细节 1. IMS 启动 1.1 IMS 开关流程 IMS 的开关在 Settings 的网络设置模块中，点击启用 VoLTE 开关，即会通过 ImsManager 去进行打开IMS 功能的流程 ImsManager 调用 TelephonyManager 的接口，最终会经过 PhoneInterfaceManager 调用 ...
商品销售统计系统java_IMS: 基于Java实现的InventoryManagementSystem进销存管理系统
weixin_36388201的博客
02-25 951
IMS-进销存管理系统基于 Java 实现的进销存管理系统(Inventory Management System)项目结构系统功能设计进货管理(Stock-In)进货入库(StockIn)：Btn->Form入库记录(StockInRecord)：Table销售管理(Stock-Out)销售出库(StockOut)：Btn->Form出库记录(StockOutRecord)：Tabl...
ims 客户端
javahigh1
08-24 246
　当前对IMS（IP多媒体子系统）技术的探讨主要集中在网络侧上，而缺少对IMS客户端的研究。本文针对IETF、3GPP、OMA（开放移动联盟）、JCP等国际标准组织中IMS客户端的相关规范进行了研究和分析，给出IMS客户端的定义和IMS客户端软件架构设计参考，指出IMS客户端区别于传统SIP客户端的一些特点以及在IMS客户端软件开发中应当注意的一些关键问题。 1、引言 IMS是基于SIP（se...
Android 7.0 IMS框架详解
限量发行的专栏
01-01 660
本文主要讲解IP Multimedia Subsystem (IMS)在Android 7.0上由谷歌Android实现的部分内容。 从APP侧一直到Telephony Framework，是不区分CS流程还是PS流程的。到了Telephony Framework模块，会依据IMS相关的状态信息(Registration Status，Service Status等)和用户设置信息(Vol...
android ims作用,Android IMS 通话应用设计
weixin_34017901的博客
05-27 1222
以下内容基于Android P code。Android电话模块是一个典型的分层结构设计，如下：分层结构IMS在CS通话的基础上增加了telephony/ims net/ims vendor/ims 和ims相关的media模块。其中：telephony/ims：主要包括了对外接口ImsPhone，通话管理中心ImsPhoneCallTracker，某一路通话ImsPhoneCall，某一路通话连...
深入Android S (12.0) 探索Framework之输入系统IMS的构成与启动
neuHenry
11-28 1520
Android 输入系统(Input System)的工作原理，包括：输入设备的管理、输入事件的加工方式及派发流程。首先输入设备包括：触摸屏，键盘，鼠标和手柄等，其中触摸屏与键盘是 Android 最普遍也是最标准的输入设备。当用户操作输入设备时，Linux内核接收到相应的硬件中断，然后将中断加工成原始的输入事件数据并写入其对应的设备节点中，在用户空间可以通过输入系统内部的读取函数将原始事件数据读出，并进行一系列翻译加工成Android输入事件，然后在所有的窗口寻找合适的事件接收者，并派发给它来消费该事件
Android7.0 IMS(1)开机初始化
ZhangJian的博客
10-13 9386
IMS(IP Multimedia Subsystem)被认为是下一代网络的核心技术，是解决移动与固网融合，引入语音、数据、视频三重融合等差异化业务的重要方式。Android作为移动网络终端的主要操作系统，也提供了对IMS的支持。 本篇博客的目的就是弄清楚Android中的IMS是如何完成开机初始化的。
蒙德贝斯特IMS-DDM伺服门机驱动系统使用与技术参数
总结，这份使用手册是蒙德贝斯特IMS-DDM伺服门机驱动系统的全方位指南，不仅提供了设备的基本信息，还涵盖了从安装、操作到维护的全过程，确保用户能够充分利用这一驱动系统实现高效自动化控制。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值