Tomasz Wasilczyk | d7c21d3 | 2017-04-17 17:02:06 -0700 | [diff] [blame] | 1 | /** |
| 2 | * Copyright (C) 2017 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 | |
Tomasz Wasilczyk | 6b4b646 | 2017-07-19 10:52:28 -0700 | [diff] [blame] | 17 | #define LOG_TAG "BroadcastRadioService.Tuner.jni" |
Tomasz Wasilczyk | d7c21d3 | 2017-04-17 17:02:06 -0700 | [diff] [blame] | 18 | #define LOG_NDEBUG 0 |
| 19 | |
Tomasz Wasilczyk | 6b4b646 | 2017-07-19 10:52:28 -0700 | [diff] [blame] | 20 | #include "Tuner.h" |
Tomasz Wasilczyk | d7c21d3 | 2017-04-17 17:02:06 -0700 | [diff] [blame] | 21 | |
Tomasz Wasilczyk | 6b4b646 | 2017-07-19 10:52:28 -0700 | [diff] [blame] | 22 | #include "convert.h" |
| 23 | #include "TunerCallback.h" |
Tomasz Wasilczyk | 2134817 | 2017-04-20 14:02:42 -0700 | [diff] [blame] | 24 | |
Tomasz Wasilczyk | 20eef7d | 2017-09-14 09:42:54 -0700 | [diff] [blame] | 25 | #include <android/hardware/broadcastradio/1.2/IBroadcastRadioFactory.h> |
Tomasz Wasilczyk | b0b98fe | 2017-06-16 14:07:33 -0700 | [diff] [blame] | 26 | #include <binder/IPCThreadState.h> |
Tomasz Wasilczyk | 8e67a33 | 2017-12-04 09:54:56 -0800 | [diff] [blame] | 27 | #include <broadcastradio-utils-1x/Utils.h> |
Tomasz Wasilczyk | d7c21d3 | 2017-04-17 17:02:06 -0700 | [diff] [blame] | 28 | #include <core_jni_helpers.h> |
Tomasz Wasilczyk | b0b98fe | 2017-06-16 14:07:33 -0700 | [diff] [blame] | 29 | #include <media/AudioSystem.h> |
Tomasz Wasilczyk | e3e8f90 | 2017-07-26 09:11:05 -0700 | [diff] [blame] | 30 | #include <nativehelper/JNIHelp.h> |
Tomasz Wasilczyk | d7c21d3 | 2017-04-17 17:02:06 -0700 | [diff] [blame] | 31 | #include <utils/Log.h> |
Tomasz Wasilczyk | d7c21d3 | 2017-04-17 17:02:06 -0700 | [diff] [blame] | 32 | |
| 33 | namespace android { |
Tomasz Wasilczyk | 2134817 | 2017-04-20 14:02:42 -0700 | [diff] [blame] | 34 | namespace server { |
Tomasz Wasilczyk | 6b4b646 | 2017-07-19 10:52:28 -0700 | [diff] [blame] | 35 | namespace BroadcastRadio { |
Tomasz Wasilczyk | 2134817 | 2017-04-20 14:02:42 -0700 | [diff] [blame] | 36 | namespace Tuner { |
Tomasz Wasilczyk | d7c21d3 | 2017-04-17 17:02:06 -0700 | [diff] [blame] | 37 | |
Tomasz Wasilczyk | e3e8f90 | 2017-07-26 09:11:05 -0700 | [diff] [blame] | 38 | using std::lock_guard; |
| 39 | using std::mutex; |
| 40 | |
Tomasz Wasilczyk | d7c21d3 | 2017-04-17 17:02:06 -0700 | [diff] [blame] | 41 | using hardware::Return; |
Tomasz Wasilczyk | 2e5a23c | 2017-06-19 14:47:03 -0700 | [diff] [blame] | 42 | using hardware::hidl_death_recipient; |
Tomasz Wasilczyk | d7c21d3 | 2017-04-17 17:02:06 -0700 | [diff] [blame] | 43 | using hardware::hidl_vec; |
| 44 | |
| 45 | namespace V1_0 = hardware::broadcastradio::V1_0; |
| 46 | namespace V1_1 = hardware::broadcastradio::V1_1; |
Tomasz Wasilczyk | 20eef7d | 2017-09-14 09:42:54 -0700 | [diff] [blame] | 47 | namespace V1_2 = hardware::broadcastradio::V1_2; |
| 48 | namespace utils = hardware::broadcastradio::utils; |
Tomasz Wasilczyk | d7c21d3 | 2017-04-17 17:02:06 -0700 | [diff] [blame] | 49 | |
Tomasz Wasilczyk | 8cfb0e8 | 2017-07-12 13:59:20 -0700 | [diff] [blame] | 50 | using V1_0::Band; |
Tomasz Wasilczyk | d7c21d3 | 2017-04-17 17:02:06 -0700 | [diff] [blame] | 51 | using V1_0::BandConfig; |
Tomasz Wasilczyk | d7c21d3 | 2017-04-17 17:02:06 -0700 | [diff] [blame] | 52 | using V1_0::MetaData; |
| 53 | using V1_0::Result; |
Tomasz Wasilczyk | 3ccddd6 | 2017-11-17 00:21:21 +0000 | [diff] [blame] | 54 | using V1_1::ProgramListResult; |
Tomasz Wasilczyk | 8e932c6 | 2017-11-17 16:18:40 +0000 | [diff] [blame] | 55 | using V1_1::VendorKeyValue; |
| 56 | using V1_2::ITunerCallback; |
Tomasz Wasilczyk | 20eef7d | 2017-09-14 09:42:54 -0700 | [diff] [blame] | 57 | using utils::HalRevision; |
Tomasz Wasilczyk | d7c21d3 | 2017-04-17 17:02:06 -0700 | [diff] [blame] | 58 | |
Tomasz Wasilczyk | e3e8f90 | 2017-07-26 09:11:05 -0700 | [diff] [blame] | 59 | static mutex gContextMutex; |
Tomasz Wasilczyk | d7c21d3 | 2017-04-17 17:02:06 -0700 | [diff] [blame] | 60 | |
Tomasz Wasilczyk | 31c8df0 | 2017-04-26 14:47:08 -0700 | [diff] [blame] | 61 | static struct { |
| 62 | struct { |
Tomasz Wasilczyk | d3d53f6 | 2017-05-15 12:55:28 -0700 | [diff] [blame] | 63 | jclass clazz; |
| 64 | jmethodID cstor; |
| 65 | jmethodID add; |
| 66 | } ArrayList; |
| 67 | struct { |
Tomasz Wasilczyk | 31c8df0 | 2017-04-26 14:47:08 -0700 | [diff] [blame] | 68 | jfieldID nativeContext; |
| 69 | jfieldID region; |
Tomasz Wasilczyk | f13b841 | 2017-05-09 11:54:35 -0700 | [diff] [blame] | 70 | jfieldID tunerCallback; |
Tomasz Wasilczyk | 31c8df0 | 2017-04-26 14:47:08 -0700 | [diff] [blame] | 71 | } Tuner; |
| 72 | } gjni; |
Tomasz Wasilczyk | d7c21d3 | 2017-04-17 17:02:06 -0700 | [diff] [blame] | 73 | |
Tomasz Wasilczyk | b0b98fe | 2017-06-16 14:07:33 -0700 | [diff] [blame] | 74 | static const char* const kAudioDeviceName = "Radio tuner source"; |
| 75 | |
Tomasz Wasilczyk | 2e5a23c | 2017-06-19 14:47:03 -0700 | [diff] [blame] | 76 | class HalDeathRecipient : public hidl_death_recipient { |
| 77 | wp<V1_1::ITunerCallback> mTunerCallback; |
| 78 | |
| 79 | public: |
| 80 | HalDeathRecipient(wp<V1_1::ITunerCallback> tunerCallback):mTunerCallback(tunerCallback) {} |
| 81 | |
| 82 | virtual void serviceDied(uint64_t cookie, const wp<hidl::base::V1_0::IBase>& who); |
| 83 | }; |
| 84 | |
Tomasz Wasilczyk | d7c21d3 | 2017-04-17 17:02:06 -0700 | [diff] [blame] | 85 | struct TunerContext { |
| 86 | TunerContext() {} |
| 87 | |
Tomasz Wasilczyk | e8f4b34 | 2017-06-19 10:48:16 -0700 | [diff] [blame] | 88 | bool mIsClosed = false; |
Tomasz Wasilczyk | 37d986d | 2017-05-08 10:41:32 -0700 | [diff] [blame] | 89 | HalRevision mHalRev; |
Tomasz Wasilczyk | b0b98fe | 2017-06-16 14:07:33 -0700 | [diff] [blame] | 90 | bool mWithAudio; |
Tomasz Wasilczyk | b1a6fea | 2017-09-12 10:21:16 -0700 | [diff] [blame] | 91 | bool mIsAudioConnected = false; |
Tomasz Wasilczyk | 8cfb0e8 | 2017-07-12 13:59:20 -0700 | [diff] [blame] | 92 | Band mBand; |
Tomasz Wasilczyk | 4482b14 | 2017-07-17 13:57:12 -0700 | [diff] [blame] | 93 | wp<V1_0::IBroadcastRadio> mHalModule; |
| 94 | wp<V1_1::IBroadcastRadio> mHalModule11; |
Tomasz Wasilczyk | 37d986d | 2017-05-08 10:41:32 -0700 | [diff] [blame] | 95 | sp<V1_0::ITuner> mHalTuner; |
| 96 | sp<V1_1::ITuner> mHalTuner11; |
Tomasz Wasilczyk | 8e932c6 | 2017-11-17 16:18:40 +0000 | [diff] [blame] | 97 | sp<V1_2::ITuner> mHalTuner12; |
Tomasz Wasilczyk | 2e5a23c | 2017-06-19 14:47:03 -0700 | [diff] [blame] | 98 | sp<HalDeathRecipient> mHalDeathRecipient; |
Tomasz Wasilczyk | d7c21d3 | 2017-04-17 17:02:06 -0700 | [diff] [blame] | 99 | |
| 100 | private: |
| 101 | DISALLOW_COPY_AND_ASSIGN(TunerContext); |
| 102 | }; |
| 103 | |
Tomasz Wasilczyk | 2134817 | 2017-04-20 14:02:42 -0700 | [diff] [blame] | 104 | static TunerContext& getNativeContext(jlong nativeContextHandle) { |
| 105 | auto nativeContext = reinterpret_cast<TunerContext*>(nativeContextHandle); |
| 106 | LOG_ALWAYS_FATAL_IF(nativeContext == nullptr, "Native context not initialized"); |
| 107 | return *nativeContext; |
| 108 | } |
Tomasz Wasilczyk | d7c21d3 | 2017-04-17 17:02:06 -0700 | [diff] [blame] | 109 | |
| 110 | /** |
| 111 | * Always lock gContextMutex when using native context. |
| 112 | */ |
Tomasz Wasilczyk | f13b841 | 2017-05-09 11:54:35 -0700 | [diff] [blame] | 113 | static TunerContext& getNativeContext(JNIEnv *env, JavaRef<jobject> const &jTuner) { |
| 114 | return getNativeContext(env->GetLongField(jTuner.get(), gjni.Tuner.nativeContext)); |
Tomasz Wasilczyk | d7c21d3 | 2017-04-17 17:02:06 -0700 | [diff] [blame] | 115 | } |
| 116 | |
Tomasz Wasilczyk | 8cfb0e8 | 2017-07-12 13:59:20 -0700 | [diff] [blame] | 117 | static jlong nativeInit(JNIEnv *env, jobject obj, jint halRev, bool withAudio, jint band) { |
Tomasz Wasilczyk | e3e8f90 | 2017-07-26 09:11:05 -0700 | [diff] [blame] | 118 | ALOGV("%s", __func__); |
| 119 | lock_guard<mutex> lk(gContextMutex); |
Tomasz Wasilczyk | d7c21d3 | 2017-04-17 17:02:06 -0700 | [diff] [blame] | 120 | |
Tomasz Wasilczyk | 2134817 | 2017-04-20 14:02:42 -0700 | [diff] [blame] | 121 | auto ctx = new TunerContext(); |
Tomasz Wasilczyk | 37d986d | 2017-05-08 10:41:32 -0700 | [diff] [blame] | 122 | ctx->mHalRev = static_cast<HalRevision>(halRev); |
Tomasz Wasilczyk | b0b98fe | 2017-06-16 14:07:33 -0700 | [diff] [blame] | 123 | ctx->mWithAudio = withAudio; |
Tomasz Wasilczyk | 8cfb0e8 | 2017-07-12 13:59:20 -0700 | [diff] [blame] | 124 | ctx->mBand = static_cast<Band>(band); |
Tomasz Wasilczyk | 2134817 | 2017-04-20 14:02:42 -0700 | [diff] [blame] | 125 | |
| 126 | static_assert(sizeof(jlong) >= sizeof(ctx), "jlong is smaller than a pointer"); |
| 127 | return reinterpret_cast<jlong>(ctx); |
Tomasz Wasilczyk | d7c21d3 | 2017-04-17 17:02:06 -0700 | [diff] [blame] | 128 | } |
| 129 | |
| 130 | static void nativeFinalize(JNIEnv *env, jobject obj, jlong nativeContext) { |
Tomasz Wasilczyk | e3e8f90 | 2017-07-26 09:11:05 -0700 | [diff] [blame] | 131 | ALOGV("%s", __func__); |
| 132 | lock_guard<mutex> lk(gContextMutex); |
Tomasz Wasilczyk | d7c21d3 | 2017-04-17 17:02:06 -0700 | [diff] [blame] | 133 | |
| 134 | auto ctx = reinterpret_cast<TunerContext*>(nativeContext); |
| 135 | delete ctx; |
| 136 | } |
| 137 | |
Tomasz Wasilczyk | 2e5a23c | 2017-06-19 14:47:03 -0700 | [diff] [blame] | 138 | void HalDeathRecipient::serviceDied(uint64_t cookie __unused, |
| 139 | const wp<hidl::base::V1_0::IBase>& who __unused) { |
| 140 | ALOGW("HAL Tuner died unexpectedly"); |
| 141 | |
| 142 | auto tunerCallback = mTunerCallback.promote(); |
| 143 | if (tunerCallback == nullptr) return; |
| 144 | |
| 145 | tunerCallback->hardwareFailure(); |
| 146 | } |
| 147 | |
Tomasz Wasilczyk | b0b98fe | 2017-06-16 14:07:33 -0700 | [diff] [blame] | 148 | // TODO(b/62713378): implement support for multiple tuners open at the same time |
| 149 | static void notifyAudioService(TunerContext& ctx, bool connected) { |
| 150 | if (!ctx.mWithAudio) return; |
Tomasz Wasilczyk | b1a6fea | 2017-09-12 10:21:16 -0700 | [diff] [blame] | 151 | if (ctx.mIsAudioConnected == connected) return; |
| 152 | ctx.mIsAudioConnected = connected; |
Tomasz Wasilczyk | b0b98fe | 2017-06-16 14:07:33 -0700 | [diff] [blame] | 153 | |
| 154 | ALOGD("Notifying AudioService about new state: %d", connected); |
| 155 | auto token = IPCThreadState::self()->clearCallingIdentity(); |
| 156 | AudioSystem::setDeviceConnectionState(AUDIO_DEVICE_IN_FM_TUNER, |
| 157 | connected ? AUDIO_POLICY_DEVICE_STATE_AVAILABLE : AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE, |
| 158 | nullptr, kAudioDeviceName); |
| 159 | IPCThreadState::self()->restoreCallingIdentity(token); |
| 160 | } |
| 161 | |
Tomasz Wasilczyk | 4482b14 | 2017-07-17 13:57:12 -0700 | [diff] [blame] | 162 | void assignHalInterfaces(JNIEnv *env, JavaRef<jobject> const &jTuner, |
| 163 | sp<V1_0::IBroadcastRadio> halModule, sp<V1_0::ITuner> halTuner) { |
Tomasz Wasilczyk | e3e8f90 | 2017-07-26 09:11:05 -0700 | [diff] [blame] | 164 | ALOGV("%s(%p)", __func__, halTuner.get()); |
Tomasz Wasilczyk | 2134817 | 2017-04-20 14:02:42 -0700 | [diff] [blame] | 165 | ALOGE_IF(halTuner == nullptr, "HAL tuner is a nullptr"); |
Tomasz Wasilczyk | e3e8f90 | 2017-07-26 09:11:05 -0700 | [diff] [blame] | 166 | lock_guard<mutex> lk(gContextMutex); |
Tomasz Wasilczyk | f13b841 | 2017-05-09 11:54:35 -0700 | [diff] [blame] | 167 | auto& ctx = getNativeContext(env, jTuner); |
Tomasz Wasilczyk | 37d986d | 2017-05-08 10:41:32 -0700 | [diff] [blame] | 168 | |
Tomasz Wasilczyk | e8f4b34 | 2017-06-19 10:48:16 -0700 | [diff] [blame] | 169 | if (ctx.mIsClosed) { |
Tomasz Wasilczyk | 1475237 | 2017-06-21 11:58:21 -0700 | [diff] [blame] | 170 | ALOGD("Tuner was closed during initialization"); |
Tomasz Wasilczyk | e8f4b34 | 2017-06-19 10:48:16 -0700 | [diff] [blame] | 171 | // dropping the last reference will close HAL tuner |
| 172 | return; |
| 173 | } |
Tomasz Wasilczyk | 2e5a23c | 2017-06-19 14:47:03 -0700 | [diff] [blame] | 174 | if (ctx.mHalTuner != nullptr) { |
| 175 | ALOGE("HAL tuner is already set."); |
| 176 | return; |
| 177 | } |
Tomasz Wasilczyk | e8f4b34 | 2017-06-19 10:48:16 -0700 | [diff] [blame] | 178 | |
Tomasz Wasilczyk | 4482b14 | 2017-07-17 13:57:12 -0700 | [diff] [blame] | 179 | ctx.mHalModule = halModule; |
| 180 | ctx.mHalModule11 = V1_1::IBroadcastRadio::castFrom(halModule).withDefault(nullptr); |
| 181 | |
Tomasz Wasilczyk | d7c21d3 | 2017-04-17 17:02:06 -0700 | [diff] [blame] | 182 | ctx.mHalTuner = halTuner; |
Tomasz Wasilczyk | 37d986d | 2017-05-08 10:41:32 -0700 | [diff] [blame] | 183 | ctx.mHalTuner11 = V1_1::ITuner::castFrom(halTuner).withDefault(nullptr); |
Tomasz Wasilczyk | 8e932c6 | 2017-11-17 16:18:40 +0000 | [diff] [blame] | 184 | ctx.mHalTuner12 = V1_2::ITuner::castFrom(halTuner).withDefault(nullptr); |
Tomasz Wasilczyk | 37d986d | 2017-05-08 10:41:32 -0700 | [diff] [blame] | 185 | ALOGW_IF(ctx.mHalRev >= HalRevision::V1_1 && ctx.mHalTuner11 == nullptr, |
| 186 | "Provided tuner does not implement 1.1 HAL"); |
Tomasz Wasilczyk | 8e932c6 | 2017-11-17 16:18:40 +0000 | [diff] [blame] | 187 | ALOGW_IF(ctx.mHalRev >= HalRevision::V1_2 && ctx.mHalTuner12 == nullptr, |
| 188 | "Provided tuner does not implement 1.2 HAL"); |
Tomasz Wasilczyk | b0b98fe | 2017-06-16 14:07:33 -0700 | [diff] [blame] | 189 | |
Tomasz Wasilczyk | 2e5a23c | 2017-06-19 14:47:03 -0700 | [diff] [blame] | 190 | ctx.mHalDeathRecipient = new HalDeathRecipient(getNativeCallback(env, jTuner)); |
| 191 | halTuner->linkToDeath(ctx.mHalDeathRecipient, 0); |
| 192 | |
Tomasz Wasilczyk | b0b98fe | 2017-06-16 14:07:33 -0700 | [diff] [blame] | 193 | notifyAudioService(ctx, true); |
Tomasz Wasilczyk | d7c21d3 | 2017-04-17 17:02:06 -0700 | [diff] [blame] | 194 | } |
| 195 | |
Tomasz Wasilczyk | 8cfb0e8 | 2017-07-12 13:59:20 -0700 | [diff] [blame] | 196 | static sp<V1_0::ITuner> getHalTuner(const TunerContext& ctx) { |
| 197 | auto tuner = ctx.mHalTuner; |
Tomasz Wasilczyk | f13b841 | 2017-05-09 11:54:35 -0700 | [diff] [blame] | 198 | LOG_ALWAYS_FATAL_IF(tuner == nullptr, "HAL tuner is not open"); |
Tomasz Wasilczyk | 8b6db4f | 2017-05-01 09:28:36 -0700 | [diff] [blame] | 199 | return tuner; |
| 200 | } |
| 201 | |
Tomasz Wasilczyk | 8e932c6 | 2017-11-17 16:18:40 +0000 | [diff] [blame] | 202 | static sp<V1_0::ITuner> getHalTuner(jlong nativeContext) { |
Tomasz Wasilczyk | e3e8f90 | 2017-07-26 09:11:05 -0700 | [diff] [blame] | 203 | lock_guard<mutex> lk(gContextMutex); |
Tomasz Wasilczyk | 8cfb0e8 | 2017-07-12 13:59:20 -0700 | [diff] [blame] | 204 | return getHalTuner(getNativeContext(nativeContext)); |
| 205 | } |
| 206 | |
Tomasz Wasilczyk | 8e932c6 | 2017-11-17 16:18:40 +0000 | [diff] [blame] | 207 | static sp<V1_1::ITuner> getHalTuner11(jlong nativeContext) { |
Tomasz Wasilczyk | e3e8f90 | 2017-07-26 09:11:05 -0700 | [diff] [blame] | 208 | lock_guard<mutex> lk(gContextMutex); |
Tomasz Wasilczyk | f13b841 | 2017-05-09 11:54:35 -0700 | [diff] [blame] | 209 | return getNativeContext(nativeContext).mHalTuner11; |
Tomasz Wasilczyk | 37d986d | 2017-05-08 10:41:32 -0700 | [diff] [blame] | 210 | } |
| 211 | |
Tomasz Wasilczyk | 8e932c6 | 2017-11-17 16:18:40 +0000 | [diff] [blame] | 212 | static sp<V1_2::ITuner> getHalTuner12(jlong nativeContext) { |
| 213 | lock_guard<mutex> lk(gContextMutex); |
| 214 | return getNativeContext(nativeContext).mHalTuner12; |
| 215 | } |
| 216 | |
Tomasz Wasilczyk | f13b841 | 2017-05-09 11:54:35 -0700 | [diff] [blame] | 217 | sp<ITunerCallback> getNativeCallback(JNIEnv *env, JavaRef<jobject> const &tuner) { |
| 218 | return TunerCallback::getNativeCallback(env, |
| 219 | env->GetObjectField(tuner.get(), gjni.Tuner.tunerCallback)); |
Tomasz Wasilczyk | d7c21d3 | 2017-04-17 17:02:06 -0700 | [diff] [blame] | 220 | } |
| 221 | |
Tomasz Wasilczyk | 31c8df0 | 2017-04-26 14:47:08 -0700 | [diff] [blame] | 222 | Region getRegion(JNIEnv *env, jobject obj) { |
| 223 | return static_cast<Region>(env->GetIntField(obj, gjni.Tuner.region)); |
| 224 | } |
| 225 | |
Tomasz Wasilczyk | 8b6db4f | 2017-05-01 09:28:36 -0700 | [diff] [blame] | 226 | static void nativeClose(JNIEnv *env, jobject obj, jlong nativeContext) { |
Tomasz Wasilczyk | e3e8f90 | 2017-07-26 09:11:05 -0700 | [diff] [blame] | 227 | lock_guard<mutex> lk(gContextMutex); |
Tomasz Wasilczyk | 2134817 | 2017-04-20 14:02:42 -0700 | [diff] [blame] | 228 | auto& ctx = getNativeContext(nativeContext); |
Tomasz Wasilczyk | e3e8f90 | 2017-07-26 09:11:05 -0700 | [diff] [blame] | 229 | |
Tomasz Wasilczyk | e8f4b34 | 2017-06-19 10:48:16 -0700 | [diff] [blame] | 230 | if (ctx.mIsClosed) return; |
| 231 | ctx.mIsClosed = true; |
| 232 | |
| 233 | if (ctx.mHalTuner == nullptr) { |
| 234 | ALOGI("Tuner closed during initialization"); |
| 235 | return; |
| 236 | } |
Tomasz Wasilczyk | b0b98fe | 2017-06-16 14:07:33 -0700 | [diff] [blame] | 237 | |
Tomasz Wasilczyk | 2134817 | 2017-04-20 14:02:42 -0700 | [diff] [blame] | 238 | ALOGI("Closing tuner %p", ctx.mHalTuner.get()); |
Tomasz Wasilczyk | 2e5a23c | 2017-06-19 14:47:03 -0700 | [diff] [blame] | 239 | |
Tomasz Wasilczyk | b0b98fe | 2017-06-16 14:07:33 -0700 | [diff] [blame] | 240 | notifyAudioService(ctx, false); |
Tomasz Wasilczyk | 2e5a23c | 2017-06-19 14:47:03 -0700 | [diff] [blame] | 241 | |
| 242 | ctx.mHalTuner->unlinkToDeath(ctx.mHalDeathRecipient); |
| 243 | ctx.mHalDeathRecipient = nullptr; |
| 244 | |
Tomasz Wasilczyk | 37d986d | 2017-05-08 10:41:32 -0700 | [diff] [blame] | 245 | ctx.mHalTuner11 = nullptr; |
Tomasz Wasilczyk | 8e932c6 | 2017-11-17 16:18:40 +0000 | [diff] [blame] | 246 | ctx.mHalTuner12 = nullptr; |
Tomasz Wasilczyk | 2134817 | 2017-04-20 14:02:42 -0700 | [diff] [blame] | 247 | ctx.mHalTuner = nullptr; |
Tomasz Wasilczyk | d7c21d3 | 2017-04-17 17:02:06 -0700 | [diff] [blame] | 248 | } |
| 249 | |
Tomasz Wasilczyk | 8b6db4f | 2017-05-01 09:28:36 -0700 | [diff] [blame] | 250 | static void nativeSetConfiguration(JNIEnv *env, jobject obj, jlong nativeContext, jobject config) { |
Tomasz Wasilczyk | e3e8f90 | 2017-07-26 09:11:05 -0700 | [diff] [blame] | 251 | ALOGV("%s", __func__); |
| 252 | lock_guard<mutex> lk(gContextMutex); |
Tomasz Wasilczyk | 8cfb0e8 | 2017-07-12 13:59:20 -0700 | [diff] [blame] | 253 | auto& ctx = getNativeContext(nativeContext); |
Tomasz Wasilczyk | e3e8f90 | 2017-07-26 09:11:05 -0700 | [diff] [blame] | 254 | |
Tomasz Wasilczyk | 8cfb0e8 | 2017-07-12 13:59:20 -0700 | [diff] [blame] | 255 | auto halTuner = getHalTuner(ctx); |
Tomasz Wasilczyk | f13b841 | 2017-05-09 11:54:35 -0700 | [diff] [blame] | 256 | if (halTuner == nullptr) return; |
Tomasz Wasilczyk | 8b6db4f | 2017-05-01 09:28:36 -0700 | [diff] [blame] | 257 | |
| 258 | Region region_unused; |
| 259 | BandConfig bandConfigHal = convert::BandConfigToHal(env, config, region_unused); |
| 260 | |
Tomasz Wasilczyk | 8cfb0e8 | 2017-07-12 13:59:20 -0700 | [diff] [blame] | 261 | if (convert::ThrowIfFailed(env, halTuner->setConfiguration(bandConfigHal))) return; |
| 262 | |
| 263 | ctx.mBand = bandConfigHal.type; |
Tomasz Wasilczyk | 8b6db4f | 2017-05-01 09:28:36 -0700 | [diff] [blame] | 264 | } |
| 265 | |
| 266 | static jobject nativeGetConfiguration(JNIEnv *env, jobject obj, jlong nativeContext, |
| 267 | Region region) { |
Tomasz Wasilczyk | e3e8f90 | 2017-07-26 09:11:05 -0700 | [diff] [blame] | 268 | ALOGV("%s", __func__); |
Tomasz Wasilczyk | 8b6db4f | 2017-05-01 09:28:36 -0700 | [diff] [blame] | 269 | auto halTuner = getHalTuner(nativeContext); |
Tomasz Wasilczyk | f13b841 | 2017-05-09 11:54:35 -0700 | [diff] [blame] | 270 | if (halTuner == nullptr) return nullptr; |
Tomasz Wasilczyk | 8b6db4f | 2017-05-01 09:28:36 -0700 | [diff] [blame] | 271 | |
| 272 | BandConfig halConfig; |
| 273 | Result halResult; |
| 274 | auto hidlResult = halTuner->getConfiguration([&](Result result, const BandConfig& config) { |
| 275 | halResult = result; |
| 276 | halConfig = config; |
| 277 | }); |
Tomasz Wasilczyk | 37d986d | 2017-05-08 10:41:32 -0700 | [diff] [blame] | 278 | if (convert::ThrowIfFailed(env, hidlResult, halResult)) { |
Tomasz Wasilczyk | 8b6db4f | 2017-05-01 09:28:36 -0700 | [diff] [blame] | 279 | return nullptr; |
| 280 | } |
| 281 | |
| 282 | return convert::BandConfigFromHal(env, halConfig, region).release(); |
| 283 | } |
| 284 | |
Tomasz Wasilczyk | b1a6fea | 2017-09-12 10:21:16 -0700 | [diff] [blame] | 285 | static void nativeSetMuted(JNIEnv *env, jobject obj, jlong nativeContext, bool mute) { |
| 286 | ALOGV("%s(%d)", __func__, mute); |
| 287 | lock_guard<mutex> lk(gContextMutex); |
| 288 | auto& ctx = getNativeContext(nativeContext); |
| 289 | |
| 290 | notifyAudioService(ctx, !mute); |
| 291 | } |
| 292 | |
Tomasz Wasilczyk | 2383793 | 2017-05-05 08:42:10 -0700 | [diff] [blame] | 293 | static void nativeStep(JNIEnv *env, jobject obj, jlong nativeContext, |
| 294 | bool directionDown, bool skipSubChannel) { |
Tomasz Wasilczyk | e3e8f90 | 2017-07-26 09:11:05 -0700 | [diff] [blame] | 295 | ALOGV("%s", __func__); |
Tomasz Wasilczyk | 2383793 | 2017-05-05 08:42:10 -0700 | [diff] [blame] | 296 | auto halTuner = getHalTuner(nativeContext); |
Tomasz Wasilczyk | f13b841 | 2017-05-09 11:54:35 -0700 | [diff] [blame] | 297 | if (halTuner == nullptr) return; |
Tomasz Wasilczyk | 2383793 | 2017-05-05 08:42:10 -0700 | [diff] [blame] | 298 | |
| 299 | auto dir = convert::DirectionToHal(directionDown); |
| 300 | convert::ThrowIfFailed(env, halTuner->step(dir, skipSubChannel)); |
| 301 | } |
| 302 | |
| 303 | static void nativeScan(JNIEnv *env, jobject obj, jlong nativeContext, |
| 304 | bool directionDown, bool skipSubChannel) { |
Tomasz Wasilczyk | e3e8f90 | 2017-07-26 09:11:05 -0700 | [diff] [blame] | 305 | ALOGV("%s", __func__); |
Tomasz Wasilczyk | 2383793 | 2017-05-05 08:42:10 -0700 | [diff] [blame] | 306 | auto halTuner = getHalTuner(nativeContext); |
Tomasz Wasilczyk | f13b841 | 2017-05-09 11:54:35 -0700 | [diff] [blame] | 307 | if (halTuner == nullptr) return; |
Tomasz Wasilczyk | 2383793 | 2017-05-05 08:42:10 -0700 | [diff] [blame] | 308 | |
| 309 | auto dir = convert::DirectionToHal(directionDown); |
| 310 | convert::ThrowIfFailed(env, halTuner->scan(dir, skipSubChannel)); |
| 311 | } |
| 312 | |
Tomasz Wasilczyk | 8cfb0e8 | 2017-07-12 13:59:20 -0700 | [diff] [blame] | 313 | static void nativeTune(JNIEnv *env, jobject obj, jlong nativeContext, jobject jSelector) { |
Tomasz Wasilczyk | e3e8f90 | 2017-07-26 09:11:05 -0700 | [diff] [blame] | 314 | ALOGV("%s", __func__); |
| 315 | lock_guard<mutex> lk(gContextMutex); |
Tomasz Wasilczyk | 8cfb0e8 | 2017-07-12 13:59:20 -0700 | [diff] [blame] | 316 | auto& ctx = getNativeContext(nativeContext); |
Tomasz Wasilczyk | e3e8f90 | 2017-07-26 09:11:05 -0700 | [diff] [blame] | 317 | |
Tomasz Wasilczyk | 8cfb0e8 | 2017-07-12 13:59:20 -0700 | [diff] [blame] | 318 | auto halTuner10 = getHalTuner(ctx); |
| 319 | auto halTuner11 = ctx.mHalTuner11; |
| 320 | if (halTuner10 == nullptr) return; |
Tomasz Wasilczyk | 37d986d | 2017-05-08 10:41:32 -0700 | [diff] [blame] | 321 | |
Tomasz Wasilczyk | 8cfb0e8 | 2017-07-12 13:59:20 -0700 | [diff] [blame] | 322 | auto selector = convert::ProgramSelectorToHal(env, jSelector); |
| 323 | if (halTuner11 != nullptr) { |
Tomasz Wasilczyk | 8316291 | 2017-08-01 10:52:58 -0700 | [diff] [blame] | 324 | convert::ThrowIfFailed(env, halTuner11->tuneByProgramSelector(selector)); |
Tomasz Wasilczyk | 8cfb0e8 | 2017-07-12 13:59:20 -0700 | [diff] [blame] | 325 | } else { |
| 326 | uint32_t channel, subChannel; |
Tomasz Wasilczyk | 20eef7d | 2017-09-14 09:42:54 -0700 | [diff] [blame] | 327 | if (!utils::getLegacyChannel(selector, &channel, &subChannel)) { |
Tomasz Wasilczyk | 8cfb0e8 | 2017-07-12 13:59:20 -0700 | [diff] [blame] | 328 | jniThrowException(env, "java/lang/IllegalArgumentException", |
| 329 | "Can't tune to non-AM/FM channel with HAL<1.1"); |
| 330 | return; |
| 331 | } |
| 332 | convert::ThrowIfFailed(env, halTuner10->tune(channel, subChannel)); |
| 333 | } |
Tomasz Wasilczyk | 2383793 | 2017-05-05 08:42:10 -0700 | [diff] [blame] | 334 | } |
| 335 | |
| 336 | static void nativeCancel(JNIEnv *env, jobject obj, jlong nativeContext) { |
Tomasz Wasilczyk | e3e8f90 | 2017-07-26 09:11:05 -0700 | [diff] [blame] | 337 | ALOGV("%s", __func__); |
Tomasz Wasilczyk | 37d986d | 2017-05-08 10:41:32 -0700 | [diff] [blame] | 338 | auto halTuner = getHalTuner(nativeContext); |
Tomasz Wasilczyk | f13b841 | 2017-05-09 11:54:35 -0700 | [diff] [blame] | 339 | if (halTuner == nullptr) return; |
Tomasz Wasilczyk | 37d986d | 2017-05-08 10:41:32 -0700 | [diff] [blame] | 340 | |
| 341 | convert::ThrowIfFailed(env, halTuner->cancel()); |
| 342 | } |
| 343 | |
Tomasz Wasilczyk | c4cd823 | 2017-07-14 10:46:15 -0700 | [diff] [blame] | 344 | static void nativeCancelAnnouncement(JNIEnv *env, jobject obj, jlong nativeContext) { |
| 345 | ALOGV("%s", __func__); |
| 346 | auto halTuner = getHalTuner11(nativeContext); |
| 347 | if (halTuner == nullptr) { |
| 348 | ALOGI("cancelling announcements is not supported with HAL < 1.1"); |
| 349 | return; |
| 350 | } |
| 351 | |
| 352 | convert::ThrowIfFailed(env, halTuner->cancelAnnouncement()); |
| 353 | } |
| 354 | |
Tomasz Wasilczyk | d3d53f6 | 2017-05-15 12:55:28 -0700 | [diff] [blame] | 355 | static bool nativeStartBackgroundScan(JNIEnv *env, jobject obj, jlong nativeContext) { |
Tomasz Wasilczyk | e3e8f90 | 2017-07-26 09:11:05 -0700 | [diff] [blame] | 356 | ALOGV("%s", __func__); |
Tomasz Wasilczyk | d3d53f6 | 2017-05-15 12:55:28 -0700 | [diff] [blame] | 357 | auto halTuner = getHalTuner11(nativeContext); |
| 358 | if (halTuner == nullptr) { |
| 359 | ALOGI("Background scan is not supported with HAL < 1.1"); |
| 360 | return false; |
| 361 | } |
| 362 | |
| 363 | auto halResult = halTuner->startBackgroundScan(); |
| 364 | |
| 365 | if (halResult.isOk() && halResult == ProgramListResult::UNAVAILABLE) return false; |
| 366 | return !convert::ThrowIfFailed(env, halResult); |
| 367 | } |
| 368 | |
Tomasz Wasilczyk | 0f1776d | 2017-08-03 11:03:49 -0700 | [diff] [blame] | 369 | static jobject nativeGetProgramList(JNIEnv *env, jobject obj, jlong nativeContext, jobject jVendorFilter) { |
Tomasz Wasilczyk | e3e8f90 | 2017-07-26 09:11:05 -0700 | [diff] [blame] | 370 | ALOGV("%s", __func__); |
Tomasz Wasilczyk | d3d53f6 | 2017-05-15 12:55:28 -0700 | [diff] [blame] | 371 | auto halTuner = getHalTuner11(nativeContext); |
| 372 | if (halTuner == nullptr) { |
| 373 | ALOGI("Program list is not supported with HAL < 1.1"); |
| 374 | return nullptr; |
| 375 | } |
| 376 | |
| 377 | JavaRef<jobject> jList; |
| 378 | ProgramListResult halResult = ProgramListResult::NOT_INITIALIZED; |
Tomasz Wasilczyk | 0f1776d | 2017-08-03 11:03:49 -0700 | [diff] [blame] | 379 | auto filter = convert::VendorInfoToHal(env, jVendorFilter); |
Tomasz Wasilczyk | d3d53f6 | 2017-05-15 12:55:28 -0700 | [diff] [blame] | 380 | auto hidlResult = halTuner->getProgramList(filter, |
| 381 | [&](ProgramListResult result, const hidl_vec<V1_1::ProgramInfo>& programList) { |
| 382 | halResult = result; |
| 383 | if (halResult != ProgramListResult::OK) return; |
| 384 | |
Tomasz Wasilczyk | cc0b479 | 2017-06-16 10:29:27 -0700 | [diff] [blame] | 385 | jList = make_javaref(env, env->NewObject(gjni.ArrayList.clazz, gjni.ArrayList.cstor)); |
Tomasz Wasilczyk | d3d53f6 | 2017-05-15 12:55:28 -0700 | [diff] [blame] | 386 | for (auto& program : programList) { |
| 387 | auto jProgram = convert::ProgramInfoFromHal(env, program); |
| 388 | env->CallBooleanMethod(jList.get(), gjni.ArrayList.add, jProgram.get()); |
| 389 | } |
| 390 | }); |
| 391 | |
| 392 | if (convert::ThrowIfFailed(env, hidlResult, halResult)) return nullptr; |
| 393 | |
| 394 | return jList.release(); |
| 395 | } |
| 396 | |
Tomasz Wasilczyk | 4482b14 | 2017-07-17 13:57:12 -0700 | [diff] [blame] | 397 | static jbyteArray nativeGetImage(JNIEnv *env, jobject obj, jlong nativeContext, jint id) { |
| 398 | ALOGV("%s(%x)", __func__, id); |
Tomasz Wasilczyk | e3e8f90 | 2017-07-26 09:11:05 -0700 | [diff] [blame] | 399 | lock_guard<mutex> lk(gContextMutex); |
Tomasz Wasilczyk | 4482b14 | 2017-07-17 13:57:12 -0700 | [diff] [blame] | 400 | auto& ctx = getNativeContext(nativeContext); |
| 401 | |
| 402 | if (ctx.mHalModule11 == nullptr) { |
| 403 | jniThrowException(env, "java/lang/IllegalStateException", |
| 404 | "Out-of-band images are not supported with HAL < 1.1"); |
| 405 | return nullptr; |
| 406 | } |
| 407 | |
| 408 | auto halModule = ctx.mHalModule11.promote(); |
| 409 | if (halModule == nullptr) { |
| 410 | ALOGE("HAL module is gone"); |
| 411 | return nullptr; |
| 412 | } |
| 413 | |
| 414 | JavaRef<jbyteArray> jRawImage = nullptr; |
| 415 | |
| 416 | auto hidlResult = halModule->getImage(id, [&](hidl_vec<uint8_t> rawImage) { |
| 417 | auto len = rawImage.size(); |
| 418 | if (len == 0) return; |
| 419 | |
| 420 | jRawImage = make_javaref(env, env->NewByteArray(len)); |
| 421 | if (jRawImage == nullptr) { |
| 422 | ALOGE("Failed to allocate byte array of len %zu", len); |
| 423 | return; |
| 424 | } |
| 425 | |
| 426 | env->SetByteArrayRegion(jRawImage.get(), 0, len, |
| 427 | reinterpret_cast<const jbyte*>(rawImage.data())); |
| 428 | }); |
| 429 | |
| 430 | if (convert::ThrowIfFailed(env, hidlResult)) return nullptr; |
| 431 | |
| 432 | return jRawImage.get(); |
| 433 | } |
| 434 | |
Tomasz Wasilczyk | d3d53f6 | 2017-05-15 12:55:28 -0700 | [diff] [blame] | 435 | static bool nativeIsAnalogForced(JNIEnv *env, jobject obj, jlong nativeContext) { |
Tomasz Wasilczyk | e3e8f90 | 2017-07-26 09:11:05 -0700 | [diff] [blame] | 436 | ALOGV("%s", __func__); |
Tomasz Wasilczyk | d3d53f6 | 2017-05-15 12:55:28 -0700 | [diff] [blame] | 437 | auto halTuner = getHalTuner11(nativeContext); |
| 438 | if (halTuner == nullptr) { |
| 439 | jniThrowException(env, "java/lang/IllegalStateException", |
| 440 | "Forced analog switch is not supported with HAL < 1.1"); |
| 441 | return false; |
| 442 | } |
| 443 | |
| 444 | bool isForced; |
| 445 | Result halResult; |
| 446 | auto hidlResult = halTuner->isAnalogForced([&](Result result, bool isForcedRet) { |
| 447 | halResult = result; |
| 448 | isForced = isForcedRet; |
| 449 | }); |
| 450 | |
| 451 | if (convert::ThrowIfFailed(env, hidlResult, halResult)) return false; |
| 452 | |
| 453 | return isForced; |
| 454 | } |
| 455 | |
| 456 | static void nativeSetAnalogForced(JNIEnv *env, jobject obj, jlong nativeContext, bool isForced) { |
Tomasz Wasilczyk | e3e8f90 | 2017-07-26 09:11:05 -0700 | [diff] [blame] | 457 | ALOGV("%s(%d)", __func__, isForced); |
Tomasz Wasilczyk | d3d53f6 | 2017-05-15 12:55:28 -0700 | [diff] [blame] | 458 | auto halTuner = getHalTuner11(nativeContext); |
| 459 | if (halTuner == nullptr) { |
| 460 | jniThrowException(env, "java/lang/IllegalStateException", |
| 461 | "Forced analog switch is not supported with HAL < 1.1"); |
| 462 | return; |
| 463 | } |
| 464 | |
| 465 | auto halResult = halTuner->setAnalogForced(isForced); |
| 466 | convert::ThrowIfFailed(env, halResult); |
| 467 | } |
| 468 | |
Tomasz Wasilczyk | 8e932c6 | 2017-11-17 16:18:40 +0000 | [diff] [blame] | 469 | static jobject nativeSetParameters(JNIEnv *env, jobject obj, jlong nativeContext, jobject jParameters) { |
| 470 | ALOGV("%s", __func__); |
| 471 | |
| 472 | auto halTuner = getHalTuner12(nativeContext); |
| 473 | if (halTuner == nullptr) { |
| 474 | ALOGI("Parameters are not supported with HAL < 1.2"); |
| 475 | return nullptr; |
| 476 | } |
| 477 | |
| 478 | JavaRef<jobject> jResults = nullptr; |
| 479 | auto parameters = convert::VendorInfoToHal(env, jParameters); |
| 480 | auto hidlResult = halTuner->setParameters(parameters, |
| 481 | [&](const hidl_vec<VendorKeyValue> results) { |
| 482 | jResults = convert::VendorInfoFromHal(env, results); |
| 483 | }); |
| 484 | |
| 485 | if (convert::ThrowIfFailed(env, hidlResult)) return nullptr; |
| 486 | |
| 487 | return jResults.release(); |
| 488 | } |
| 489 | |
| 490 | static jobject nativeGetParameters(JNIEnv *env, jobject obj, jlong nativeContext, jobject jKeys) { |
| 491 | ALOGV("%s", __func__); |
| 492 | |
| 493 | auto halTuner = getHalTuner12(nativeContext); |
| 494 | if (halTuner == nullptr) { |
| 495 | ALOGI("Parameters are not supported with HAL < 1.2"); |
| 496 | return nullptr; |
| 497 | } |
| 498 | |
| 499 | JavaRef<jobject> jResults = nullptr; |
| 500 | auto keys = convert::StringListToHal(env, jKeys); |
| 501 | auto hidlResult = halTuner->getParameters(keys, |
| 502 | [&](const hidl_vec<VendorKeyValue> parameters) { |
| 503 | jResults = convert::VendorInfoFromHal(env, parameters); |
| 504 | }); |
| 505 | |
| 506 | if (convert::ThrowIfFailed(env, hidlResult)) return nullptr; |
| 507 | |
| 508 | return jResults.release(); |
| 509 | } |
| 510 | |
Tomasz Wasilczyk | d7c21d3 | 2017-04-17 17:02:06 -0700 | [diff] [blame] | 511 | static const JNINativeMethod gTunerMethods[] = { |
Tomasz Wasilczyk | 8cfb0e8 | 2017-07-12 13:59:20 -0700 | [diff] [blame] | 512 | { "nativeInit", "(IZI)J", (void*)nativeInit }, |
Tomasz Wasilczyk | d7c21d3 | 2017-04-17 17:02:06 -0700 | [diff] [blame] | 513 | { "nativeFinalize", "(J)V", (void*)nativeFinalize }, |
Tomasz Wasilczyk | 8b6db4f | 2017-05-01 09:28:36 -0700 | [diff] [blame] | 514 | { "nativeClose", "(J)V", (void*)nativeClose }, |
| 515 | { "nativeSetConfiguration", "(JLandroid/hardware/radio/RadioManager$BandConfig;)V", |
| 516 | (void*)nativeSetConfiguration }, |
| 517 | { "nativeGetConfiguration", "(JI)Landroid/hardware/radio/RadioManager$BandConfig;", |
| 518 | (void*)nativeGetConfiguration }, |
Tomasz Wasilczyk | b1a6fea | 2017-09-12 10:21:16 -0700 | [diff] [blame] | 519 | { "nativeSetMuted", "(JZ)V", (void*)nativeSetMuted }, |
Tomasz Wasilczyk | 2383793 | 2017-05-05 08:42:10 -0700 | [diff] [blame] | 520 | { "nativeStep", "(JZZ)V", (void*)nativeStep }, |
| 521 | { "nativeScan", "(JZZ)V", (void*)nativeScan }, |
Tomasz Wasilczyk | 8cfb0e8 | 2017-07-12 13:59:20 -0700 | [diff] [blame] | 522 | { "nativeTune", "(JLandroid/hardware/radio/ProgramSelector;)V", (void*)nativeTune }, |
Tomasz Wasilczyk | 2383793 | 2017-05-05 08:42:10 -0700 | [diff] [blame] | 523 | { "nativeCancel", "(J)V", (void*)nativeCancel }, |
Tomasz Wasilczyk | c4cd823 | 2017-07-14 10:46:15 -0700 | [diff] [blame] | 524 | { "nativeCancelAnnouncement", "(J)V", (void*)nativeCancelAnnouncement }, |
Tomasz Wasilczyk | d3d53f6 | 2017-05-15 12:55:28 -0700 | [diff] [blame] | 525 | { "nativeStartBackgroundScan", "(J)Z", (void*)nativeStartBackgroundScan }, |
Tomasz Wasilczyk | 0f1776d | 2017-08-03 11:03:49 -0700 | [diff] [blame] | 526 | { "nativeGetProgramList", "(JLjava/util/Map;)Ljava/util/List;", |
Tomasz Wasilczyk | d3d53f6 | 2017-05-15 12:55:28 -0700 | [diff] [blame] | 527 | (void*)nativeGetProgramList }, |
Tomasz Wasilczyk | 4482b14 | 2017-07-17 13:57:12 -0700 | [diff] [blame] | 528 | { "nativeGetImage", "(JI)[B", (void*)nativeGetImage}, |
Tomasz Wasilczyk | d3d53f6 | 2017-05-15 12:55:28 -0700 | [diff] [blame] | 529 | { "nativeIsAnalogForced", "(J)Z", (void*)nativeIsAnalogForced }, |
| 530 | { "nativeSetAnalogForced", "(JZ)V", (void*)nativeSetAnalogForced }, |
Tomasz Wasilczyk | 8e932c6 | 2017-11-17 16:18:40 +0000 | [diff] [blame] | 531 | { "nativeSetParameters", "(JLjava/util/Map;)Ljava/util/Map;", (void*)nativeSetParameters }, |
| 532 | { "nativeGetParameters", "(JLjava/util/List;)Ljava/util/Map;", (void*)nativeGetParameters }, |
Tomasz Wasilczyk | d7c21d3 | 2017-04-17 17:02:06 -0700 | [diff] [blame] | 533 | }; |
| 534 | |
Tomasz Wasilczyk | 2134817 | 2017-04-20 14:02:42 -0700 | [diff] [blame] | 535 | } // namespace Tuner |
Tomasz Wasilczyk | 6b4b646 | 2017-07-19 10:52:28 -0700 | [diff] [blame] | 536 | } // namespace BroadcastRadio |
Tomasz Wasilczyk | 2134817 | 2017-04-20 14:02:42 -0700 | [diff] [blame] | 537 | } // namespace server |
| 538 | |
Tomasz Wasilczyk | 6b4b646 | 2017-07-19 10:52:28 -0700 | [diff] [blame] | 539 | void register_android_server_broadcastradio_Tuner(JavaVM *vm, JNIEnv *env) { |
| 540 | using namespace server::BroadcastRadio::Tuner; |
Tomasz Wasilczyk | 2134817 | 2017-04-20 14:02:42 -0700 | [diff] [blame] | 541 | |
Tomasz Wasilczyk | 6b4b646 | 2017-07-19 10:52:28 -0700 | [diff] [blame] | 542 | register_android_server_broadcastradio_TunerCallback(vm, env); |
Tomasz Wasilczyk | 31c8df0 | 2017-04-26 14:47:08 -0700 | [diff] [blame] | 543 | |
Tomasz Wasilczyk | df01326 | 2017-12-13 11:47:20 -0800 | [diff] [blame] | 544 | auto tunerClass = FindClassOrDie(env, "com/android/server/broadcastradio/hal1/Tuner"); |
Tomasz Wasilczyk | 31c8df0 | 2017-04-26 14:47:08 -0700 | [diff] [blame] | 545 | gjni.Tuner.nativeContext = GetFieldIDOrDie(env, tunerClass, "mNativeContext", "J"); |
| 546 | gjni.Tuner.region = GetFieldIDOrDie(env, tunerClass, "mRegion", "I"); |
Tomasz Wasilczyk | f13b841 | 2017-05-09 11:54:35 -0700 | [diff] [blame] | 547 | gjni.Tuner.tunerCallback = GetFieldIDOrDie(env, tunerClass, "mTunerCallback", |
Tomasz Wasilczyk | df01326 | 2017-12-13 11:47:20 -0800 | [diff] [blame] | 548 | "Lcom/android/server/broadcastradio/hal1/TunerCallback;"); |
Tomasz Wasilczyk | d7c21d3 | 2017-04-17 17:02:06 -0700 | [diff] [blame] | 549 | |
Tomasz Wasilczyk | d3d53f6 | 2017-05-15 12:55:28 -0700 | [diff] [blame] | 550 | auto arrayListClass = FindClassOrDie(env, "java/util/ArrayList"); |
| 551 | gjni.ArrayList.clazz = MakeGlobalRefOrDie(env, arrayListClass); |
| 552 | gjni.ArrayList.cstor = GetMethodIDOrDie(env, arrayListClass, "<init>", "()V"); |
| 553 | gjni.ArrayList.add = GetMethodIDOrDie(env, arrayListClass, "add", "(Ljava/lang/Object;)Z"); |
| 554 | |
Tomasz Wasilczyk | df01326 | 2017-12-13 11:47:20 -0800 | [diff] [blame] | 555 | auto res = jniRegisterNativeMethods(env, "com/android/server/broadcastradio/hal1/Tuner", |
Tomasz Wasilczyk | d7c21d3 | 2017-04-17 17:02:06 -0700 | [diff] [blame] | 556 | gTunerMethods, NELEM(gTunerMethods)); |
| 557 | LOG_ALWAYS_FATAL_IF(res < 0, "Unable to register native methods."); |
| 558 | } |
| 559 | |
Tomasz Wasilczyk | 2134817 | 2017-04-20 14:02:42 -0700 | [diff] [blame] | 560 | } // namespace android |