1/*
2 * Copyright (C) 2013 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#define LOG_TAG "InputEventSender"
18
19//#define LOG_NDEBUG 0
20
21#include "JNIHelp.h"
22
23#include <android_runtime/AndroidRuntime.h>
24#include <utils/Log.h>
25#include <utils/Looper.h>
26#include <utils/threads.h>
27#include <utils/KeyedVector.h>
28#include <input/InputTransport.h>
29#include "android_os_MessageQueue.h"
30#include "android_view_InputChannel.h"
31#include "android_view_KeyEvent.h"
32#include "android_view_MotionEvent.h"
33
34#include <ScopedLocalRef.h>
35
36#include "core_jni_helpers.h"
37
38namespace android {
39
40// Log debug messages about the dispatch cycle.
41static const bool kDebugDispatchCycle = false;
42
43static struct {
44    jclass clazz;
45
46    jmethodID dispatchInputEventFinished;
47} gInputEventSenderClassInfo;
48
49
50class NativeInputEventSender : public LooperCallback {
51public:
52    NativeInputEventSender(JNIEnv* env,
53            jobject senderWeak, const sp<InputChannel>& inputChannel,
54            const sp<MessageQueue>& messageQueue);
55
56    status_t initialize();
57    void dispose();
58    status_t sendKeyEvent(uint32_t seq, const KeyEvent* event);
59    status_t sendMotionEvent(uint32_t seq, const MotionEvent* event);
60
61protected:
62    virtual ~NativeInputEventSender();
63
64private:
65    jobject mSenderWeakGlobal;
66    InputPublisher mInputPublisher;
67    sp<MessageQueue> mMessageQueue;
68    KeyedVector<uint32_t, uint32_t> mPublishedSeqMap;
69    uint32_t mNextPublishedSeq;
70
71    const char* getInputChannelName() {
72        return mInputPublisher.getChannel()->getName().string();
73    }
74
75    virtual int handleEvent(int receiveFd, int events, void* data);
76    status_t receiveFinishedSignals(JNIEnv* env);
77};
78
79
80NativeInputEventSender::NativeInputEventSender(JNIEnv* env,
81        jobject senderWeak, const sp<InputChannel>& inputChannel,
82        const sp<MessageQueue>& messageQueue) :
83        mSenderWeakGlobal(env->NewGlobalRef(senderWeak)),
84        mInputPublisher(inputChannel), mMessageQueue(messageQueue),
85        mNextPublishedSeq(1) {
86    if (kDebugDispatchCycle) {
87        ALOGD("channel '%s' ~ Initializing input event sender.", getInputChannelName());
88    }
89}
90
91NativeInputEventSender::~NativeInputEventSender() {
92    JNIEnv* env = AndroidRuntime::getJNIEnv();
93    env->DeleteGlobalRef(mSenderWeakGlobal);
94}
95
96status_t NativeInputEventSender::initialize() {
97    int receiveFd = mInputPublisher.getChannel()->getFd();
98    mMessageQueue->getLooper()->addFd(receiveFd, 0, ALOOPER_EVENT_INPUT, this, NULL);
99    return OK;
100}
101
102void NativeInputEventSender::dispose() {
103    if (kDebugDispatchCycle) {
104        ALOGD("channel '%s' ~ Disposing input event sender.", getInputChannelName());
105    }
106
107    mMessageQueue->getLooper()->removeFd(mInputPublisher.getChannel()->getFd());
108}
109
110status_t NativeInputEventSender::sendKeyEvent(uint32_t seq, const KeyEvent* event) {
111    if (kDebugDispatchCycle) {
112        ALOGD("channel '%s' ~ Sending key event, seq=%u.", getInputChannelName(), seq);
113    }
114
115    uint32_t publishedSeq = mNextPublishedSeq++;
116    status_t status = mInputPublisher.publishKeyEvent(publishedSeq,
117            event->getDeviceId(), event->getSource(), event->getAction(), event->getFlags(),
118            event->getKeyCode(), event->getScanCode(), event->getMetaState(),
119            event->getRepeatCount(), event->getDownTime(), event->getEventTime());
120    if (status) {
121        ALOGW("Failed to send key event on channel '%s'.  status=%d",
122                getInputChannelName(), status);
123        return status;
124    }
125    mPublishedSeqMap.add(publishedSeq, seq);
126    return OK;
127}
128
129status_t NativeInputEventSender::sendMotionEvent(uint32_t seq, const MotionEvent* event) {
130    if (kDebugDispatchCycle) {
131        ALOGD("channel '%s' ~ Sending motion event, seq=%u.", getInputChannelName(), seq);
132    }
133
134    uint32_t publishedSeq;
135    for (size_t i = 0; i <= event->getHistorySize(); i++) {
136        publishedSeq = mNextPublishedSeq++;
137        status_t status = mInputPublisher.publishMotionEvent(publishedSeq,
138                event->getDeviceId(), event->getSource(),
139                event->getAction(), event->getActionButton(), event->getFlags(),
140                event->getEdgeFlags(), event->getMetaState(), event->getButtonState(),
141                event->getXOffset(), event->getYOffset(),
142                event->getXPrecision(), event->getYPrecision(),
143                event->getDownTime(), event->getHistoricalEventTime(i),
144                event->getPointerCount(), event->getPointerProperties(),
145                event->getHistoricalRawPointerCoords(0, i));
146        if (status) {
147            ALOGW("Failed to send motion event sample on channel '%s'.  status=%d",
148                    getInputChannelName(), status);
149            return status;
150        }
151    }
152    mPublishedSeqMap.add(publishedSeq, seq);
153    return OK;
154}
155
156int NativeInputEventSender::handleEvent(int receiveFd, int events, void* data) {
157    if (events & (ALOOPER_EVENT_ERROR | ALOOPER_EVENT_HANGUP)) {
158        // This error typically occurs when the consumer has closed the input channel
159        // as part of finishing an IME session, in which case the publisher will
160        // soon be disposed as well.
161        if (kDebugDispatchCycle) {
162            ALOGD("channel '%s' ~ Consumer closed input channel or an error occurred.  "
163                    "events=0x%x", getInputChannelName(), events);
164        }
165
166        return 0; // remove the callback
167    }
168
169    if (!(events & ALOOPER_EVENT_INPUT)) {
170        ALOGW("channel '%s' ~ Received spurious callback for unhandled poll event.  "
171                "events=0x%x", getInputChannelName(), events);
172        return 1;
173    }
174
175    JNIEnv* env = AndroidRuntime::getJNIEnv();
176    status_t status = receiveFinishedSignals(env);
177    mMessageQueue->raiseAndClearException(env, "handleReceiveCallback");
178    return status == OK || status == NO_MEMORY ? 1 : 0;
179}
180
181status_t NativeInputEventSender::receiveFinishedSignals(JNIEnv* env) {
182    if (kDebugDispatchCycle) {
183        ALOGD("channel '%s' ~ Receiving finished signals.", getInputChannelName());
184    }
185
186    ScopedLocalRef<jobject> senderObj(env, NULL);
187    bool skipCallbacks = false;
188    for (;;) {
189        uint32_t publishedSeq;
190        bool handled;
191        status_t status = mInputPublisher.receiveFinishedSignal(&publishedSeq, &handled);
192        if (status) {
193            if (status == WOULD_BLOCK) {
194                return OK;
195            }
196            ALOGE("channel '%s' ~ Failed to consume finished signals.  status=%d",
197                    getInputChannelName(), status);
198            return status;
199        }
200
201        ssize_t index = mPublishedSeqMap.indexOfKey(publishedSeq);
202        if (index >= 0) {
203            uint32_t seq = mPublishedSeqMap.valueAt(index);
204            mPublishedSeqMap.removeItemsAt(index);
205
206            if (kDebugDispatchCycle) {
207                ALOGD("channel '%s' ~ Received finished signal, seq=%u, handled=%s, "
208                        "pendingEvents=%zu.",
209                        getInputChannelName(), seq, handled ? "true" : "false",
210                        mPublishedSeqMap.size());
211            }
212
213            if (!skipCallbacks) {
214                if (!senderObj.get()) {
215                    senderObj.reset(jniGetReferent(env, mSenderWeakGlobal));
216                    if (!senderObj.get()) {
217                        ALOGW("channel '%s' ~ Sender object was finalized "
218                                "without being disposed.", getInputChannelName());
219                        return DEAD_OBJECT;
220                    }
221                }
222
223                env->CallVoidMethod(senderObj.get(),
224                        gInputEventSenderClassInfo.dispatchInputEventFinished,
225                        jint(seq), jboolean(handled));
226                if (env->ExceptionCheck()) {
227                    ALOGE("Exception dispatching finished signal.");
228                    skipCallbacks = true;
229                }
230            }
231        }
232    }
233}
234
235
236static jlong nativeInit(JNIEnv* env, jclass clazz, jobject senderWeak,
237        jobject inputChannelObj, jobject messageQueueObj) {
238    sp<InputChannel> inputChannel = android_view_InputChannel_getInputChannel(env,
239            inputChannelObj);
240    if (inputChannel == NULL) {
241        jniThrowRuntimeException(env, "InputChannel is not initialized.");
242        return 0;
243    }
244
245    sp<MessageQueue> messageQueue = android_os_MessageQueue_getMessageQueue(env, messageQueueObj);
246    if (messageQueue == NULL) {
247        jniThrowRuntimeException(env, "MessageQueue is not initialized.");
248        return 0;
249    }
250
251    sp<NativeInputEventSender> sender = new NativeInputEventSender(env,
252            senderWeak, inputChannel, messageQueue);
253    status_t status = sender->initialize();
254    if (status) {
255        String8 message;
256        message.appendFormat("Failed to initialize input event sender.  status=%d", status);
257        jniThrowRuntimeException(env, message.string());
258        return 0;
259    }
260
261    sender->incStrong(gInputEventSenderClassInfo.clazz); // retain a reference for the object
262    return reinterpret_cast<jlong>(sender.get());
263}
264
265static void nativeDispose(JNIEnv* env, jclass clazz, jlong senderPtr) {
266    sp<NativeInputEventSender> sender =
267            reinterpret_cast<NativeInputEventSender*>(senderPtr);
268    sender->dispose();
269    sender->decStrong(gInputEventSenderClassInfo.clazz); // drop reference held by the object
270}
271
272static jboolean nativeSendKeyEvent(JNIEnv* env, jclass clazz, jlong senderPtr,
273        jint seq, jobject eventObj) {
274    sp<NativeInputEventSender> sender =
275            reinterpret_cast<NativeInputEventSender*>(senderPtr);
276    KeyEvent event;
277    android_view_KeyEvent_toNative(env, eventObj, &event);
278    status_t status = sender->sendKeyEvent(seq, &event);
279    return !status;
280}
281
282static jboolean nativeSendMotionEvent(JNIEnv* env, jclass clazz, jlong senderPtr,
283        jint seq, jobject eventObj) {
284    sp<NativeInputEventSender> sender =
285            reinterpret_cast<NativeInputEventSender*>(senderPtr);
286    MotionEvent* event = android_view_MotionEvent_getNativePtr(env, eventObj);
287    status_t status = sender->sendMotionEvent(seq, event);
288    return !status;
289}
290
291
292static const JNINativeMethod gMethods[] = {
293    /* name, signature, funcPtr */
294    { "nativeInit",
295            "(Ljava/lang/ref/WeakReference;Landroid/view/InputChannel;Landroid/os/MessageQueue;)J",
296            (void*)nativeInit },
297    { "nativeDispose", "(J)V",
298            (void*)nativeDispose },
299    { "nativeSendKeyEvent", "(JILandroid/view/KeyEvent;)Z",
300            (void*)nativeSendKeyEvent },
301    { "nativeSendMotionEvent", "(JILandroid/view/MotionEvent;)Z",
302            (void*)nativeSendMotionEvent },
303};
304
305int register_android_view_InputEventSender(JNIEnv* env) {
306    int res = RegisterMethodsOrDie(env, "android/view/InputEventSender", gMethods, NELEM(gMethods));
307
308    jclass clazz = FindClassOrDie(env, "android/view/InputEventSender");
309    gInputEventSenderClassInfo.clazz = MakeGlobalRefOrDie(env, clazz);
310
311    gInputEventSenderClassInfo.dispatchInputEventFinished = GetMethodIDOrDie(
312            env, gInputEventSenderClassInfo.clazz, "dispatchInputEventFinished", "(IZ)V");
313
314    return res;
315}
316
317} // namespace android
318