1 /*
2 * Copyright 2014 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 "TvInputHal"
18
19 //#define LOG_NDEBUG 0
20
21 #include "android_os_MessageQueue.h"
22 #include "android_runtime/AndroidRuntime.h"
23 #include "android_runtime/android_view_Surface.h"
24 #include <nativehelper/JNIHelp.h>
25 #include "jni.h"
26
27 #include <android/hardware/tv/input/1.0/ITvInputCallback.h>
28 #include <android/hardware/tv/input/1.0/ITvInput.h>
29 #include <android/hardware/tv/input/1.0/types.h>
30 #include <gui/Surface.h>
31 #include <utils/Errors.h>
32 #include <utils/KeyedVector.h>
33 #include <utils/Log.h>
34 #include <utils/Looper.h>
35 #include <utils/NativeHandle.h>
36 #include <hardware/tv_input.h>
37
38 using ::android::hardware::audio::common::V2_0::AudioDevice;
39 using ::android::hardware::tv::input::V1_0::ITvInput;
40 using ::android::hardware::tv::input::V1_0::ITvInputCallback;
41 using ::android::hardware::tv::input::V1_0::Result;
42 using ::android::hardware::tv::input::V1_0::TvInputDeviceInfo;
43 using ::android::hardware::tv::input::V1_0::TvInputEvent;
44 using ::android::hardware::tv::input::V1_0::TvInputEventType;
45 using ::android::hardware::tv::input::V1_0::TvInputType;
46 using ::android::hardware::tv::input::V1_0::TvStreamConfig;
47 using ::android::hardware::Return;
48 using ::android::hardware::Void;
49 using ::android::hardware::hidl_vec;
50 using ::android::hardware::hidl_string;
51
52 namespace android {
53
54 static struct {
55 jmethodID deviceAvailable;
56 jmethodID deviceUnavailable;
57 jmethodID streamConfigsChanged;
58 jmethodID firstFrameCaptured;
59 } gTvInputHalClassInfo;
60
61 static struct {
62 jclass clazz;
63 } gTvStreamConfigClassInfo;
64
65 static struct {
66 jclass clazz;
67
68 jmethodID constructor;
69 jmethodID streamId;
70 jmethodID type;
71 jmethodID maxWidth;
72 jmethodID maxHeight;
73 jmethodID generation;
74 jmethodID build;
75 } gTvStreamConfigBuilderClassInfo;
76
77 static struct {
78 jclass clazz;
79
80 jmethodID constructor;
81 jmethodID deviceId;
82 jmethodID type;
83 jmethodID hdmiPortId;
84 jmethodID cableConnectionStatus;
85 jmethodID audioType;
86 jmethodID audioAddress;
87 jmethodID build;
88 } gTvInputHardwareInfoBuilderClassInfo;
89
90 ////////////////////////////////////////////////////////////////////////////////
91
92 class BufferProducerThread : public Thread {
93 public:
94 BufferProducerThread(tv_input_device_t* device, int deviceId, const tv_stream_t* stream);
95
96 virtual status_t readyToRun();
97
98 void setSurface(const sp<Surface>& surface);
99 void onCaptured(uint32_t seq, bool succeeded);
100 void shutdown();
101
102 private:
103 Mutex mLock;
104 Condition mCondition;
105 sp<Surface> mSurface;
106 tv_input_device_t* mDevice;
107 int mDeviceId;
108 tv_stream_t mStream;
109 sp<ANativeWindowBuffer_t> mBuffer;
110 enum {
111 CAPTURING,
112 CAPTURED,
113 RELEASED,
114 } mBufferState;
115 uint32_t mSeq;
116 bool mShutdown;
117
118 virtual bool threadLoop();
119
120 void setSurfaceLocked(const sp<Surface>& surface);
121 };
122
BufferProducerThread(tv_input_device_t * device,int deviceId,const tv_stream_t * stream)123 BufferProducerThread::BufferProducerThread(
124 tv_input_device_t* device, int deviceId, const tv_stream_t* stream)
125 : Thread(false),
126 mDevice(device),
127 mDeviceId(deviceId),
128 mBuffer(NULL),
129 mBufferState(RELEASED),
130 mSeq(0u),
131 mShutdown(false) {
132 memcpy(&mStream, stream, sizeof(mStream));
133 }
134
readyToRun()135 status_t BufferProducerThread::readyToRun() {
136 sp<ANativeWindow> anw(mSurface);
137 status_t err = native_window_set_usage(anw.get(), mStream.buffer_producer.usage);
138 if (err != NO_ERROR) {
139 return err;
140 }
141 err = native_window_set_buffers_dimensions(
142 anw.get(), mStream.buffer_producer.width, mStream.buffer_producer.height);
143 if (err != NO_ERROR) {
144 return err;
145 }
146 err = native_window_set_buffers_format(anw.get(), mStream.buffer_producer.format);
147 if (err != NO_ERROR) {
148 return err;
149 }
150 return NO_ERROR;
151 }
152
setSurface(const sp<Surface> & surface)153 void BufferProducerThread::setSurface(const sp<Surface>& surface) {
154 Mutex::Autolock autoLock(&mLock);
155 setSurfaceLocked(surface);
156 }
157
setSurfaceLocked(const sp<Surface> & surface)158 void BufferProducerThread::setSurfaceLocked(const sp<Surface>& surface) {
159 if (surface == mSurface) {
160 return;
161 }
162
163 if (mBufferState == CAPTURING) {
164 mDevice->cancel_capture(mDevice, mDeviceId, mStream.stream_id, mSeq);
165 }
166 while (mBufferState == CAPTURING) {
167 status_t err = mCondition.waitRelative(mLock, s2ns(1));
168 if (err != NO_ERROR) {
169 ALOGE("error %d while wating for buffer state to change.", err);
170 break;
171 }
172 }
173 mBuffer.clear();
174 mBufferState = RELEASED;
175
176 mSurface = surface;
177 mCondition.broadcast();
178 }
179
onCaptured(uint32_t seq,bool succeeded)180 void BufferProducerThread::onCaptured(uint32_t seq, bool succeeded) {
181 Mutex::Autolock autoLock(&mLock);
182 if (seq != mSeq) {
183 ALOGW("Incorrect sequence value: expected %u actual %u", mSeq, seq);
184 }
185 if (mBufferState != CAPTURING) {
186 ALOGW("mBufferState != CAPTURING : instead %d", mBufferState);
187 }
188 if (succeeded) {
189 mBufferState = CAPTURED;
190 } else {
191 mBuffer.clear();
192 mBufferState = RELEASED;
193 }
194 mCondition.broadcast();
195 }
196
shutdown()197 void BufferProducerThread::shutdown() {
198 Mutex::Autolock autoLock(&mLock);
199 mShutdown = true;
200 setSurfaceLocked(NULL);
201 requestExitAndWait();
202 }
203
threadLoop()204 bool BufferProducerThread::threadLoop() {
205 Mutex::Autolock autoLock(&mLock);
206
207 status_t err = NO_ERROR;
208 if (mSurface == NULL) {
209 err = mCondition.waitRelative(mLock, s2ns(1));
210 // It's OK to time out here.
211 if (err != NO_ERROR && err != TIMED_OUT) {
212 ALOGE("error %d while wating for non-null surface to be set", err);
213 return false;
214 }
215 return true;
216 }
217 sp<ANativeWindow> anw(mSurface);
218 while (mBufferState == CAPTURING) {
219 err = mCondition.waitRelative(mLock, s2ns(1));
220 if (err != NO_ERROR) {
221 ALOGE("error %d while wating for buffer state to change.", err);
222 return false;
223 }
224 }
225 if (mBufferState == CAPTURED && anw != NULL) {
226 err = anw->queueBuffer(anw.get(), mBuffer.get(), -1);
227 if (err != NO_ERROR) {
228 ALOGE("error %d while queueing buffer to surface", err);
229 return false;
230 }
231 mBuffer.clear();
232 mBufferState = RELEASED;
233 }
234 if (mBuffer == NULL && !mShutdown && anw != NULL) {
235 ANativeWindowBuffer_t* buffer = NULL;
236 err = native_window_dequeue_buffer_and_wait(anw.get(), &buffer);
237 if (err != NO_ERROR) {
238 ALOGE("error %d while dequeueing buffer to surface", err);
239 return false;
240 }
241 mBuffer = buffer;
242 mBufferState = CAPTURING;
243 mDevice->request_capture(mDevice, mDeviceId, mStream.stream_id,
244 buffer->handle, ++mSeq);
245 }
246
247 return true;
248 }
249
250 ////////////////////////////////////////////////////////////////////////////////
251
252 class JTvInputHal {
253 public:
254 ~JTvInputHal();
255
256 static JTvInputHal* createInstance(JNIEnv* env, jobject thiz, const sp<Looper>& looper);
257
258 int addOrUpdateStream(int deviceId, int streamId, const sp<Surface>& surface);
259 int removeStream(int deviceId, int streamId);
260 const hidl_vec<TvStreamConfig> getStreamConfigs(int deviceId);
261
262 void onDeviceAvailable(const TvInputDeviceInfo& info);
263 void onDeviceUnavailable(int deviceId);
264 void onStreamConfigurationsChanged(int deviceId);
265 void onCaptured(int deviceId, int streamId, uint32_t seq, bool succeeded);
266
267 private:
268 // Connection between a surface and a stream.
269 class Connection {
270 public:
Connection()271 Connection() {}
272
273 sp<Surface> mSurface;
274 tv_stream_type_t mStreamType;
275
276 // Only valid when mStreamType == TV_STREAM_TYPE_INDEPENDENT_VIDEO_SOURCE
277 sp<NativeHandle> mSourceHandle;
278 // Only valid when mStreamType == TV_STREAM_TYPE_BUFFER_PRODUCER
279 sp<BufferProducerThread> mThread;
280 };
281
282 class NotifyHandler : public MessageHandler {
283 public:
284 NotifyHandler(JTvInputHal* hal, const TvInputEvent& event);
285
286 virtual void handleMessage(const Message& message);
287
288 private:
289 TvInputEvent mEvent;
290 JTvInputHal* mHal;
291 };
292
293 class TvInputCallback : public ITvInputCallback {
294 public:
295 explicit TvInputCallback(JTvInputHal* hal);
296 Return<void> notify(const TvInputEvent& event) override;
297 private:
298 JTvInputHal* mHal;
299 };
300
301 JTvInputHal(JNIEnv* env, jobject thiz, sp<ITvInput> tvInput, const sp<Looper>& looper);
302
303 Mutex mLock;
304 jweak mThiz;
305 sp<Looper> mLooper;
306
307 KeyedVector<int, KeyedVector<int, Connection> > mConnections;
308
309 sp<ITvInput> mTvInput;
310 sp<ITvInputCallback> mTvInputCallback;
311 };
312
JTvInputHal(JNIEnv * env,jobject thiz,sp<ITvInput> tvInput,const sp<Looper> & looper)313 JTvInputHal::JTvInputHal(JNIEnv* env, jobject thiz, sp<ITvInput> tvInput,
314 const sp<Looper>& looper) {
315 mThiz = env->NewWeakGlobalRef(thiz);
316 mTvInput = tvInput;
317 mLooper = looper;
318 mTvInputCallback = new TvInputCallback(this);
319 mTvInput->setCallback(mTvInputCallback);
320 }
321
~JTvInputHal()322 JTvInputHal::~JTvInputHal() {
323 mTvInput->setCallback(nullptr);
324 JNIEnv* env = AndroidRuntime::getJNIEnv();
325 env->DeleteWeakGlobalRef(mThiz);
326 mThiz = NULL;
327 }
328
createInstance(JNIEnv * env,jobject thiz,const sp<Looper> & looper)329 JTvInputHal* JTvInputHal::createInstance(JNIEnv* env, jobject thiz, const sp<Looper>& looper) {
330 // TODO(b/31632518)
331 sp<ITvInput> tvInput = ITvInput::getService();
332 if (tvInput == nullptr) {
333 ALOGE("Couldn't get tv.input service.");
334 return nullptr;
335 }
336
337 return new JTvInputHal(env, thiz, tvInput, looper);
338 }
339
addOrUpdateStream(int deviceId,int streamId,const sp<Surface> & surface)340 int JTvInputHal::addOrUpdateStream(int deviceId, int streamId, const sp<Surface>& surface) {
341 KeyedVector<int, Connection>& connections = mConnections.editValueFor(deviceId);
342 if (connections.indexOfKey(streamId) < 0) {
343 connections.add(streamId, Connection());
344 }
345 Connection& connection = connections.editValueFor(streamId);
346 if (connection.mSurface == surface) {
347 // Nothing to do
348 return NO_ERROR;
349 }
350 // Clear the surface in the connection.
351 if (connection.mSurface != NULL) {
352 if (connection.mStreamType == TV_STREAM_TYPE_INDEPENDENT_VIDEO_SOURCE) {
353 if (Surface::isValid(connection.mSurface)) {
354 connection.mSurface->setSidebandStream(NULL);
355 }
356 }
357 connection.mSurface.clear();
358 }
359 if (connection.mSourceHandle == NULL && connection.mThread == NULL) {
360 // Need to configure stream
361 Result result = Result::UNKNOWN;
362 hidl_vec<TvStreamConfig> list;
363 mTvInput->getStreamConfigurations(deviceId,
364 [&result, &list](Result res, hidl_vec<TvStreamConfig> configs) {
365 result = res;
366 if (res == Result::OK) {
367 list = configs;
368 }
369 });
370 if (result != Result::OK) {
371 ALOGE("Couldn't get stream configs for device id:%d result:%d", deviceId, result);
372 return UNKNOWN_ERROR;
373 }
374 int configIndex = -1;
375 for (size_t i = 0; i < list.size(); ++i) {
376 if (list[i].streamId == streamId) {
377 configIndex = i;
378 break;
379 }
380 }
381 if (configIndex == -1) {
382 ALOGE("Cannot find a config with given stream ID: %d", streamId);
383 return BAD_VALUE;
384 }
385 connection.mStreamType = TV_STREAM_TYPE_INDEPENDENT_VIDEO_SOURCE;
386
387 result = Result::UNKNOWN;
388 const native_handle_t* sidebandStream;
389 mTvInput->openStream(deviceId, streamId,
390 [&result, &sidebandStream](Result res, const native_handle_t* handle) {
391 result = res;
392 if (res == Result::OK) {
393 if (handle) {
394 sidebandStream = native_handle_clone(handle);
395 } else {
396 result = Result::UNKNOWN;
397 }
398 }
399 });
400 if (result != Result::OK) {
401 ALOGE("Couldn't open stream. device id:%d stream id:%d result:%d", deviceId, streamId,
402 result);
403 return UNKNOWN_ERROR;
404 }
405 connection.mSourceHandle = NativeHandle::create((native_handle_t*)sidebandStream, true);
406 }
407 connection.mSurface = surface;
408 if (connection.mSurface != nullptr) {
409 connection.mSurface->setSidebandStream(connection.mSourceHandle);
410 }
411 return NO_ERROR;
412 }
413
removeStream(int deviceId,int streamId)414 int JTvInputHal::removeStream(int deviceId, int streamId) {
415 KeyedVector<int, Connection>& connections = mConnections.editValueFor(deviceId);
416 if (connections.indexOfKey(streamId) < 0) {
417 return BAD_VALUE;
418 }
419 Connection& connection = connections.editValueFor(streamId);
420 if (connection.mSurface == NULL) {
421 // Nothing to do
422 return NO_ERROR;
423 }
424 if (Surface::isValid(connection.mSurface)) {
425 connection.mSurface->setSidebandStream(NULL);
426 }
427 connection.mSurface.clear();
428 if (connection.mThread != NULL) {
429 connection.mThread->shutdown();
430 connection.mThread.clear();
431 }
432 if (mTvInput->closeStream(deviceId, streamId) != Result::OK) {
433 ALOGE("Couldn't close stream. device id:%d stream id:%d", deviceId, streamId);
434 return BAD_VALUE;
435 }
436 if (connection.mSourceHandle != NULL) {
437 connection.mSourceHandle.clear();
438 }
439 return NO_ERROR;
440 }
441
getStreamConfigs(int deviceId)442 const hidl_vec<TvStreamConfig> JTvInputHal::getStreamConfigs(int deviceId) {
443 Result result = Result::UNKNOWN;
444 hidl_vec<TvStreamConfig> list;
445 mTvInput->getStreamConfigurations(deviceId,
446 [&result, &list](Result res, hidl_vec<TvStreamConfig> configs) {
447 result = res;
448 if (res == Result::OK) {
449 list = configs;
450 }
451 });
452 if (result != Result::OK) {
453 ALOGE("Couldn't get stream configs for device id:%d result:%d", deviceId, result);
454 }
455 return list;
456 }
457
onDeviceAvailable(const TvInputDeviceInfo & info)458 void JTvInputHal::onDeviceAvailable(const TvInputDeviceInfo& info) {
459 {
460 Mutex::Autolock autoLock(&mLock);
461 mConnections.add(info.deviceId, KeyedVector<int, Connection>());
462 }
463 JNIEnv* env = AndroidRuntime::getJNIEnv();
464
465 jobject builder = env->NewObject(
466 gTvInputHardwareInfoBuilderClassInfo.clazz,
467 gTvInputHardwareInfoBuilderClassInfo.constructor);
468 env->CallObjectMethod(
469 builder, gTvInputHardwareInfoBuilderClassInfo.deviceId, info.deviceId);
470 env->CallObjectMethod(
471 builder, gTvInputHardwareInfoBuilderClassInfo.type, info.type);
472 if (info.type == TvInputType::HDMI) {
473 env->CallObjectMethod(
474 builder, gTvInputHardwareInfoBuilderClassInfo.hdmiPortId, info.portId);
475 }
476 env->CallObjectMethod(
477 builder, gTvInputHardwareInfoBuilderClassInfo.cableConnectionStatus,
478 info.cableConnectionStatus);
479 env->CallObjectMethod(
480 builder, gTvInputHardwareInfoBuilderClassInfo.audioType, info.audioType);
481 if (info.audioType != AudioDevice::NONE) {
482 uint8_t buffer[info.audioAddress.size() + 1];
483 memcpy(buffer, info.audioAddress.data(), info.audioAddress.size());
484 buffer[info.audioAddress.size()] = '\0';
485 jstring audioAddress = env->NewStringUTF(reinterpret_cast<const char *>(buffer));
486 env->CallObjectMethod(
487 builder, gTvInputHardwareInfoBuilderClassInfo.audioAddress, audioAddress);
488 env->DeleteLocalRef(audioAddress);
489 }
490
491 jobject infoObject = env->CallObjectMethod(builder, gTvInputHardwareInfoBuilderClassInfo.build);
492
493 env->CallVoidMethod(
494 mThiz,
495 gTvInputHalClassInfo.deviceAvailable,
496 infoObject);
497
498 env->DeleteLocalRef(builder);
499 env->DeleteLocalRef(infoObject);
500 }
501
onDeviceUnavailable(int deviceId)502 void JTvInputHal::onDeviceUnavailable(int deviceId) {
503 {
504 Mutex::Autolock autoLock(&mLock);
505 KeyedVector<int, Connection>& connections = mConnections.editValueFor(deviceId);
506 for (size_t i = 0; i < connections.size(); ++i) {
507 removeStream(deviceId, connections.keyAt(i));
508 }
509 connections.clear();
510 mConnections.removeItem(deviceId);
511 }
512 JNIEnv* env = AndroidRuntime::getJNIEnv();
513 env->CallVoidMethod(
514 mThiz,
515 gTvInputHalClassInfo.deviceUnavailable,
516 deviceId);
517 }
518
onStreamConfigurationsChanged(int deviceId)519 void JTvInputHal::onStreamConfigurationsChanged(int deviceId) {
520 {
521 Mutex::Autolock autoLock(&mLock);
522 KeyedVector<int, Connection>& connections = mConnections.editValueFor(deviceId);
523 for (size_t i = 0; i < connections.size(); ++i) {
524 removeStream(deviceId, connections.keyAt(i));
525 }
526 connections.clear();
527 }
528 JNIEnv* env = AndroidRuntime::getJNIEnv();
529 env->CallVoidMethod(
530 mThiz,
531 gTvInputHalClassInfo.streamConfigsChanged,
532 deviceId);
533 }
534
onCaptured(int deviceId,int streamId,uint32_t seq,bool succeeded)535 void JTvInputHal::onCaptured(int deviceId, int streamId, uint32_t seq, bool succeeded) {
536 sp<BufferProducerThread> thread;
537 {
538 Mutex::Autolock autoLock(&mLock);
539 KeyedVector<int, Connection>& connections = mConnections.editValueFor(deviceId);
540 Connection& connection = connections.editValueFor(streamId);
541 if (connection.mThread == NULL) {
542 ALOGE("capture thread not existing.");
543 return;
544 }
545 thread = connection.mThread;
546 }
547 thread->onCaptured(seq, succeeded);
548 if (seq == 0) {
549 JNIEnv* env = AndroidRuntime::getJNIEnv();
550 env->CallVoidMethod(
551 mThiz,
552 gTvInputHalClassInfo.firstFrameCaptured,
553 deviceId,
554 streamId);
555 }
556 }
557
NotifyHandler(JTvInputHal * hal,const TvInputEvent & event)558 JTvInputHal::NotifyHandler::NotifyHandler(JTvInputHal* hal, const TvInputEvent& event) {
559 mHal = hal;
560 mEvent = event;
561 }
562
handleMessage(const Message & message)563 void JTvInputHal::NotifyHandler::handleMessage(const Message& message) {
564 switch (mEvent.type) {
565 case TvInputEventType::DEVICE_AVAILABLE: {
566 mHal->onDeviceAvailable(mEvent.deviceInfo);
567 } break;
568 case TvInputEventType::DEVICE_UNAVAILABLE: {
569 mHal->onDeviceUnavailable(mEvent.deviceInfo.deviceId);
570 } break;
571 case TvInputEventType::STREAM_CONFIGURATIONS_CHANGED: {
572 mHal->onStreamConfigurationsChanged(mEvent.deviceInfo.deviceId);
573 } break;
574 default:
575 ALOGE("Unrecognizable event");
576 }
577 }
578
TvInputCallback(JTvInputHal * hal)579 JTvInputHal::TvInputCallback::TvInputCallback(JTvInputHal* hal) {
580 mHal = hal;
581 }
582
notify(const TvInputEvent & event)583 Return<void> JTvInputHal::TvInputCallback::notify(const TvInputEvent& event) {
584 mHal->mLooper->sendMessage(new NotifyHandler(mHal, event), static_cast<int>(event.type));
585 return Void();
586 }
587
588 ////////////////////////////////////////////////////////////////////////////////
589
nativeOpen(JNIEnv * env,jobject thiz,jobject messageQueueObj)590 static jlong nativeOpen(JNIEnv* env, jobject thiz, jobject messageQueueObj) {
591 sp<MessageQueue> messageQueue =
592 android_os_MessageQueue_getMessageQueue(env, messageQueueObj);
593 return (jlong)JTvInputHal::createInstance(env, thiz, messageQueue->getLooper());
594 }
595
nativeAddOrUpdateStream(JNIEnv * env,jclass clazz,jlong ptr,jint deviceId,jint streamId,jobject jsurface)596 static int nativeAddOrUpdateStream(JNIEnv* env, jclass clazz,
597 jlong ptr, jint deviceId, jint streamId, jobject jsurface) {
598 JTvInputHal* tvInputHal = (JTvInputHal*)ptr;
599 if (!jsurface) {
600 return BAD_VALUE;
601 }
602 sp<Surface> surface(android_view_Surface_getSurface(env, jsurface));
603 if (!Surface::isValid(surface)) {
604 return BAD_VALUE;
605 }
606 return tvInputHal->addOrUpdateStream(deviceId, streamId, surface);
607 }
608
nativeRemoveStream(JNIEnv * env,jclass clazz,jlong ptr,jint deviceId,jint streamId)609 static int nativeRemoveStream(JNIEnv* env, jclass clazz,
610 jlong ptr, jint deviceId, jint streamId) {
611 JTvInputHal* tvInputHal = (JTvInputHal*)ptr;
612 return tvInputHal->removeStream(deviceId, streamId);
613 }
614
nativeGetStreamConfigs(JNIEnv * env,jclass clazz,jlong ptr,jint deviceId,jint generation)615 static jobjectArray nativeGetStreamConfigs(JNIEnv* env, jclass clazz,
616 jlong ptr, jint deviceId, jint generation) {
617 JTvInputHal* tvInputHal = (JTvInputHal*)ptr;
618 const hidl_vec<TvStreamConfig> configs = tvInputHal->getStreamConfigs(deviceId);
619
620 jobjectArray result = env->NewObjectArray(configs.size(), gTvStreamConfigClassInfo.clazz, NULL);
621 for (size_t i = 0; i < configs.size(); ++i) {
622 jobject builder = env->NewObject(
623 gTvStreamConfigBuilderClassInfo.clazz,
624 gTvStreamConfigBuilderClassInfo.constructor);
625 env->CallObjectMethod(
626 builder, gTvStreamConfigBuilderClassInfo.streamId, configs[i].streamId);
627 env->CallObjectMethod(
628 builder, gTvStreamConfigBuilderClassInfo.type,
629 TV_STREAM_TYPE_INDEPENDENT_VIDEO_SOURCE);
630 env->CallObjectMethod(
631 builder, gTvStreamConfigBuilderClassInfo.maxWidth, configs[i].maxVideoWidth);
632 env->CallObjectMethod(
633 builder, gTvStreamConfigBuilderClassInfo.maxHeight, configs[i].maxVideoHeight);
634 env->CallObjectMethod(
635 builder, gTvStreamConfigBuilderClassInfo.generation, generation);
636
637 jobject config = env->CallObjectMethod(builder, gTvStreamConfigBuilderClassInfo.build);
638
639 env->SetObjectArrayElement(result, i, config);
640
641 env->DeleteLocalRef(config);
642 env->DeleteLocalRef(builder);
643 }
644 return result;
645 }
646
nativeClose(JNIEnv * env,jclass clazz,jlong ptr)647 static void nativeClose(JNIEnv* env, jclass clazz, jlong ptr) {
648 JTvInputHal* tvInputHal = (JTvInputHal*)ptr;
649 delete tvInputHal;
650 }
651
652 static const JNINativeMethod gTvInputHalMethods[] = {
653 /* name, signature, funcPtr */
654 { "nativeOpen", "(Landroid/os/MessageQueue;)J",
655 (void*) nativeOpen },
656 { "nativeAddOrUpdateStream", "(JIILandroid/view/Surface;)I",
657 (void*) nativeAddOrUpdateStream },
658 { "nativeRemoveStream", "(JII)I",
659 (void*) nativeRemoveStream },
660 { "nativeGetStreamConfigs", "(JII)[Landroid/media/tv/TvStreamConfig;",
661 (void*) nativeGetStreamConfigs },
662 { "nativeClose", "(J)V",
663 (void*) nativeClose },
664 };
665
666 #define FIND_CLASS(var, className) \
667 var = env->FindClass(className); \
668 LOG_FATAL_IF(! (var), "Unable to find class " className)
669
670 #define GET_METHOD_ID(var, clazz, methodName, fieldDescriptor) \
671 var = env->GetMethodID(clazz, methodName, fieldDescriptor); \
672 LOG_FATAL_IF(! (var), "Unable to find method" methodName)
673
register_android_server_tv_TvInputHal(JNIEnv * env)674 int register_android_server_tv_TvInputHal(JNIEnv* env) {
675 int res = jniRegisterNativeMethods(env, "com/android/server/tv/TvInputHal",
676 gTvInputHalMethods, NELEM(gTvInputHalMethods));
677 LOG_FATAL_IF(res < 0, "Unable to register native methods.");
678 (void)res; // Don't complain about unused variable in the LOG_NDEBUG case
679
680 jclass clazz;
681 FIND_CLASS(clazz, "com/android/server/tv/TvInputHal");
682
683 GET_METHOD_ID(
684 gTvInputHalClassInfo.deviceAvailable, clazz,
685 "deviceAvailableFromNative", "(Landroid/media/tv/TvInputHardwareInfo;)V");
686 GET_METHOD_ID(
687 gTvInputHalClassInfo.deviceUnavailable, clazz, "deviceUnavailableFromNative", "(I)V");
688 GET_METHOD_ID(
689 gTvInputHalClassInfo.streamConfigsChanged, clazz,
690 "streamConfigsChangedFromNative", "(I)V");
691 GET_METHOD_ID(
692 gTvInputHalClassInfo.firstFrameCaptured, clazz,
693 "firstFrameCapturedFromNative", "(II)V");
694
695 FIND_CLASS(gTvStreamConfigClassInfo.clazz, "android/media/tv/TvStreamConfig");
696 gTvStreamConfigClassInfo.clazz = jclass(env->NewGlobalRef(gTvStreamConfigClassInfo.clazz));
697
698 FIND_CLASS(gTvStreamConfigBuilderClassInfo.clazz, "android/media/tv/TvStreamConfig$Builder");
699 gTvStreamConfigBuilderClassInfo.clazz =
700 jclass(env->NewGlobalRef(gTvStreamConfigBuilderClassInfo.clazz));
701
702 GET_METHOD_ID(
703 gTvStreamConfigBuilderClassInfo.constructor,
704 gTvStreamConfigBuilderClassInfo.clazz,
705 "<init>", "()V");
706 GET_METHOD_ID(
707 gTvStreamConfigBuilderClassInfo.streamId,
708 gTvStreamConfigBuilderClassInfo.clazz,
709 "streamId", "(I)Landroid/media/tv/TvStreamConfig$Builder;");
710 GET_METHOD_ID(
711 gTvStreamConfigBuilderClassInfo.type,
712 gTvStreamConfigBuilderClassInfo.clazz,
713 "type", "(I)Landroid/media/tv/TvStreamConfig$Builder;");
714 GET_METHOD_ID(
715 gTvStreamConfigBuilderClassInfo.maxWidth,
716 gTvStreamConfigBuilderClassInfo.clazz,
717 "maxWidth", "(I)Landroid/media/tv/TvStreamConfig$Builder;");
718 GET_METHOD_ID(
719 gTvStreamConfigBuilderClassInfo.maxHeight,
720 gTvStreamConfigBuilderClassInfo.clazz,
721 "maxHeight", "(I)Landroid/media/tv/TvStreamConfig$Builder;");
722 GET_METHOD_ID(
723 gTvStreamConfigBuilderClassInfo.generation,
724 gTvStreamConfigBuilderClassInfo.clazz,
725 "generation", "(I)Landroid/media/tv/TvStreamConfig$Builder;");
726 GET_METHOD_ID(
727 gTvStreamConfigBuilderClassInfo.build,
728 gTvStreamConfigBuilderClassInfo.clazz,
729 "build", "()Landroid/media/tv/TvStreamConfig;");
730
731 FIND_CLASS(gTvInputHardwareInfoBuilderClassInfo.clazz,
732 "android/media/tv/TvInputHardwareInfo$Builder");
733 gTvInputHardwareInfoBuilderClassInfo.clazz =
734 jclass(env->NewGlobalRef(gTvInputHardwareInfoBuilderClassInfo.clazz));
735
736 GET_METHOD_ID(
737 gTvInputHardwareInfoBuilderClassInfo.constructor,
738 gTvInputHardwareInfoBuilderClassInfo.clazz,
739 "<init>", "()V");
740 GET_METHOD_ID(
741 gTvInputHardwareInfoBuilderClassInfo.deviceId,
742 gTvInputHardwareInfoBuilderClassInfo.clazz,
743 "deviceId", "(I)Landroid/media/tv/TvInputHardwareInfo$Builder;");
744 GET_METHOD_ID(
745 gTvInputHardwareInfoBuilderClassInfo.type,
746 gTvInputHardwareInfoBuilderClassInfo.clazz,
747 "type", "(I)Landroid/media/tv/TvInputHardwareInfo$Builder;");
748 GET_METHOD_ID(
749 gTvInputHardwareInfoBuilderClassInfo.hdmiPortId,
750 gTvInputHardwareInfoBuilderClassInfo.clazz,
751 "hdmiPortId", "(I)Landroid/media/tv/TvInputHardwareInfo$Builder;");
752 GET_METHOD_ID(
753 gTvInputHardwareInfoBuilderClassInfo.cableConnectionStatus,
754 gTvInputHardwareInfoBuilderClassInfo.clazz,
755 "cableConnectionStatus", "(I)Landroid/media/tv/TvInputHardwareInfo$Builder;");
756 GET_METHOD_ID(
757 gTvInputHardwareInfoBuilderClassInfo.audioType,
758 gTvInputHardwareInfoBuilderClassInfo.clazz,
759 "audioType", "(I)Landroid/media/tv/TvInputHardwareInfo$Builder;");
760 GET_METHOD_ID(
761 gTvInputHardwareInfoBuilderClassInfo.audioAddress,
762 gTvInputHardwareInfoBuilderClassInfo.clazz,
763 "audioAddress", "(Ljava/lang/String;)Landroid/media/tv/TvInputHardwareInfo$Builder;");
764 GET_METHOD_ID(
765 gTvInputHardwareInfoBuilderClassInfo.build,
766 gTvInputHardwareInfoBuilderClassInfo.clazz,
767 "build", "()Landroid/media/tv/TvInputHardwareInfo;");
768
769 return 0;
770 }
771
772 } /* namespace android */
773