jni/JniFilterEngine.cpp - Issue 29345540: Issue 4030 - Move JNI bindings into separate library project

Side by Side Diff: jni/JniFilterEngine.cpp

Issue 29345540: Issue 4030 - Move JNI bindings into separate library project (Closed)

Patch Set: Changeset in adblockplusandroid repo Created July 22, 2016, 12:10 p.m.

Left:
Right:

Use n/p to move between diff chunks; N/P to move between comments.

Jump to:

View unified diff | Download patch

OLD	NEW
	(Empty)
1 /*

2 * This file is part of Adblock Plus <https://adblockplus.org/>,

3 * Copyright (C) 2006-2016 Eyeo GmbH

4 *

5 * Adblock Plus is free software: you can redistribute it and/or modify

6 * it under the terms of the GNU General Public License version 3 as

7 * published by the Free Software Foundation.

8 *

9 * Adblock Plus is distributed in the hope that it will be useful,

10 * but WITHOUT ANY WARRANTY; without even the implied warranty of

11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

12 * GNU General Public License for more details.

13 *

14 * You should have received a copy of the GNU General Public License

15 * along with Adblock Plus. If not, see <http://www.gnu.org/licenses/>.

16 */

17

18 #include <AdblockPlus.h>

19 #include "Utils.h"

20 #include "JniCallbacks.h"

21

22 static jobject SubscriptionsToArrayList(JNIEnv* env, std::vector<AdblockPlus::Su bscriptionPtr>& subscriptions)

23 {

24 jobject list = NewJniArrayList(env);

25

26 for (std::vector<AdblockPlus::SubscriptionPtr>::iterator it = subscriptions.be gin(), end = subscriptions.end(); it != end; it++)

27 {

28 JniAddObjectToList(env, list, NewJniSubscription(env, *it));

29 }

30

31 return list;

32 }

33

34 static AdblockPlus::FilterEngine::ContentType ConvertContentType(JNIEnv *env,

35 jobject jContentType)

36 {

37 JniLocalReference<jclass> contentTypeClass(env,

38 env->GetObjectClass(jContentType));

39 jmethodID nameMethod = env->GetMethodID(*contentTypeClass, "name",

40 "()Ljava/lang/String;");

41 JniLocalReference<jstring> jValue(env,

42 (jstring) env->CallObjectMethod(jContentType, nameMethod));

43 const std::string value = JniJavaToStdString(env, *jValue);

44 return AdblockPlus::FilterEngine::StringToContentType(value);

45 }

46

47 static jlong JNICALL JniCtor(JNIEnv* env, jclass clazz, jlong enginePtr)

48 {

49 try

50 {

51 AdblockPlus::JsEnginePtr& jsEngine = *JniLongToTypePtr<AdblockPlus::JsEngine Ptr>(enginePtr);

52 return JniPtrToLong(new AdblockPlus::FilterEngine(jsEngine));

53 }

54 CATCH_THROW_AND_RETURN(env, 0)

55 }

56

57 static void JNICALL JniDtor(JNIEnv* env, jclass clazz, jlong ptr)

58 {

59 delete JniLongToTypePtr<AdblockPlus::FilterEngine>(ptr);

60 }

61

62 static jboolean JNICALL JniIsFirstRun(JNIEnv* env, jclass clazz, jlong ptr)

63 {

64 try

65 {

66 AdblockPlus::FilterEngine* engine = JniLongToTypePtr<AdblockPlus::FilterEngi ne>(ptr);

67

68 return engine->IsFirstRun() ? JNI_TRUE : JNI_FALSE;

69 }

70 CATCH_THROW_AND_RETURN(env, JNI_FALSE);

71 }

72

73 static jobject JNICALL JniGetFilter(JNIEnv* env, jclass clazz, jlong ptr, jstrin g jText)

74 {

75 AdblockPlus::FilterEngine* engine = JniLongToTypePtr<AdblockPlus::FilterEngine >(ptr);

76 std::string text = JniJavaToStdString(env, jText);

77

78 try

79 {

80 AdblockPlus::FilterPtr filter = engine->GetFilter(text);

81

82 return NewJniFilter(env, filter);

83 }

84 CATCH_THROW_AND_RETURN(env, 0);

85 }

86

87 static jobject JNICALL JniGetListedFilters(JNIEnv* env, jclass clazz, jlong ptr)

88 {

89 AdblockPlus::FilterEngine* engine = JniLongToTypePtr<AdblockPlus::FilterEngine >(ptr);

90

91 try

92 {

93 std::vector<AdblockPlus::FilterPtr> filters = engine->GetListedFilters();

94

95 jobject list = NewJniArrayList(env);

96

97 for (std::vector<AdblockPlus::FilterPtr>::iterator it = filters.begin(), end = filters.end(); it != end; it++)

98 {

99 JniAddObjectToList(env, list, JniLocalReference<jobject>(env, NewJniFilte r(env, it)));

100 }

101

102 return list;

103 }

104 CATCH_THROW_AND_RETURN(env, 0);

105 }

106

107 static jobject JNICALL JniGetSubscription(JNIEnv* env, jclass clazz, jlong ptr, jstring jUrl)

108 {

109 AdblockPlus::FilterEngine* engine = JniLongToTypePtr<AdblockPlus::FilterEngine >(ptr);

110 std::string url = JniJavaToStdString(env, jUrl);

111

112 try

113 {

114 AdblockPlus::SubscriptionPtr subscription = engine->GetSubscription(url);

115

116 return NewJniSubscription(env, subscription);

117 }

118 CATCH_THROW_AND_RETURN(env, 0);

119 }

120

121 static void JNICALL JniShowNextNotification(JNIEnv* env, jclass clazz, jlong ptr , jstring jUrl)

122 {

123 AdblockPlus::FilterEngine* engine = JniLongToTypePtr<AdblockPlus::FilterEngine >(ptr);

124 std::string url = JniJavaToStdString(env, jUrl);

125

126 try

127 {

128 engine->ShowNextNotification(url);

129 }

130 CATCH_AND_THROW(env);

131 }

132

133 static void JNICALL JniSetShowNotificationCallback(JNIEnv* env, jclass clazz,

134 jlong ptr, jlong callbackPtr)

135 {

136 AdblockPlus::FilterEngine* const engine =

137 JniLongToTypePtr<AdblockPlus::FilterEngine>(ptr);

138 JniShowNotificationCallback* const callback =

139 JniLongToTypePtr<JniShowNotificationCallback>(callbackPtr);

140 AdblockPlus::FilterEngine::ShowNotificationCallback showNotificationCallback =

141 std::bind(&JniShowNotificationCallback::Callback, callback,

142 std::placeholders::_1);

143 try

144 {

145 engine->SetShowNotificationCallback(showNotificationCallback);

146 }

147 CATCH_AND_THROW(env)

148 }

149

150 static void JNICALL JniRemoveShowNotificationCallback(JNIEnv* env, jclass clazz, jlong ptr)

151 {

152 AdblockPlus::FilterEngine* engine = JniLongToTypePtr<AdblockPlus::FilterEngine >(ptr);

153

154 try

155 {

156 engine->RemoveShowNotificationCallback();

157 }

158 CATCH_AND_THROW(env);

159 }

160

161 static jobject JNICALL JniGetListedSubscriptions(JNIEnv* env, jclass clazz, jlon g ptr)

162 {

163 AdblockPlus::FilterEngine* engine = JniLongToTypePtr<AdblockPlus::FilterEngine >(ptr);

164

165 try

166 {

167 std::vector<AdblockPlus::SubscriptionPtr> subscriptions = engine->GetListedS ubscriptions();

168

169 return SubscriptionsToArrayList(env, subscriptions);

170 }

171 CATCH_THROW_AND_RETURN(env, 0);

172 }

173

174 static jobject JNICALL JniFetchAvailableSubscriptions(JNIEnv* env, jclass clazz, jlong ptr)

175 {

176 AdblockPlus::FilterEngine* engine = JniLongToTypePtr<AdblockPlus::FilterEngine >(ptr);

177

178 try

179 {

180 std::vector<AdblockPlus::SubscriptionPtr> subscriptions = engine->FetchAvail ableSubscriptions();

181

182 return SubscriptionsToArrayList(env, subscriptions);

183 }

184 CATCH_THROW_AND_RETURN(env, 0);

185 }

186

187 static void JNICALL JniRemoveUpdateAvailableCallback(JNIEnv* env, jclass clazz,

188 jlong ptr)

189 {

190 AdblockPlus::FilterEngine* const engine =

191 JniLongToTypePtr<AdblockPlus::FilterEngine>(ptr);

192 try

193 {

194 engine->RemoveUpdateAvailableCallback();

195 }

196 CATCH_AND_THROW(env)

197 }

198

199 static void JNICALL JniSetUpdateAvailableCallback(JNIEnv* env, jclass clazz,

200 jlong ptr, jlong callbackPtr)

201 {

202 AdblockPlus::FilterEngine* const engine =

203 JniLongToTypePtr<AdblockPlus::FilterEngine>(ptr);

204 JniUpdateAvailableCallback* const callback =

205 JniLongToTypePtr<JniUpdateAvailableCallback>(callbackPtr);

206 AdblockPlus::FilterEngine::UpdateAvailableCallback updateAvailableCallback =

207 std::bind(&JniUpdateAvailableCallback::Callback, callback,

208 std::placeholders::_1);

209 try

210 {

211 engine->SetUpdateAvailableCallback(updateAvailableCallback);

212 }

213 CATCH_AND_THROW(env)

214 }

215

216 static void JNICALL JniRemoveFilterChangeCallback(JNIEnv* env, jclass clazz, jlo ng ptr)

217 {

218 AdblockPlus::FilterEngine* engine = JniLongToTypePtr<AdblockPlus::FilterEngine >(ptr);

219

220 try

221 {

222 engine->RemoveFilterChangeCallback();

223 }

224 CATCH_AND_THROW(env)

225 }

226

227 static void JNICALL JniSetFilterChangeCallback(JNIEnv* env, jclass clazz,

228 jlong ptr, jlong filterPtr)

229 {

230 AdblockPlus::FilterEngine* engine =

231 JniLongToTypePtr<AdblockPlus::FilterEngine>(ptr);

232 JniFilterChangeCallback* callback = JniLongToTypePtr<JniFilterChangeCallback>(

233 filterPtr);

234

235 AdblockPlus::FilterEngine::FilterChangeCallback filterCallback =

236 std::bind(&JniFilterChangeCallback::Callback, callback,

237 std::placeholders::_1, std::placeholders::_2);

238

239 try

240 {

241 engine->SetFilterChangeCallback(filterCallback);

242 }

243 CATCH_AND_THROW(env)

244 }

245

246 static void JNICALL JniForceUpdateCheck(JNIEnv* env, jclass clazz, jlong ptr, jl ong updaterPtr)

247 {

248 AdblockPlus::FilterEngine* engine = JniLongToTypePtr<AdblockPlus::FilterEngine >(ptr);

249 JniUpdateCheckDoneCallback* callback =

250 JniLongToTypePtr<JniUpdateCheckDoneCallback>(updaterPtr);

251

252 AdblockPlus::FilterEngine::UpdateCheckDoneCallback

253 updateCheckDoneCallback = 0;

254

255 if (updaterPtr)

256 {

257 updateCheckDoneCallback =

258 std::bind(&JniUpdateCheckDoneCallback::Callback, callback,

259 std::placeholders::_1);

260 }

261

262 try

263 {

264 engine->ForceUpdateCheck(updateCheckDoneCallback);

265 }

266 CATCH_AND_THROW(env)

267 }

268

269 static jobject JNICALL JniGetElementHidingSelectors(JNIEnv* env, jclass clazz,

270 jlong ptr, jstring jDomain)

271 {

272 AdblockPlus::FilterEngine* engine =

273 JniLongToTypePtr<AdblockPlus::FilterEngine>(ptr);

274

275 std::string domain = JniJavaToStdString(env, jDomain);

276

277 try

278 {

279 std::vector<std::string> selectors = engine->GetElementHidingSelectors(

280 domain);

281

282 jobject list = NewJniArrayList(env);

283

284 for (std::vector<std::string>::iterator it = selectors.begin(), end =

285 selectors.end(); it != end; it++)

286 {

287 JniAddObjectToList(env, list,

288 *JniLocalReference<jstring>(env, env->NewStringUTF(it->c_str())));

289 }

290

291 return list;

292 }

293 CATCH_THROW_AND_RETURN(env, 0)

294 }

295

296 static jobject JNICALL JniMatches(JNIEnv* env, jclass clazz, jlong ptr, jstring jUrl, jobject jContentType, jstring jDocumentUrl)

297 {

298 AdblockPlus::FilterEngine* engine = JniLongToTypePtr<AdblockPlus::FilterEngine >(ptr);

299

300 std::string url = JniJavaToStdString(env, jUrl);

301 AdblockPlus::FilterEngine::ContentType contentType =

302 ConvertContentType(env, jContentType);

303 std::string documentUrl = JniJavaToStdString(env, jDocumentUrl);

304

305 try

306 {

307 AdblockPlus::FilterPtr filter = engine->Matches(url, contentType, documentUr l);

308

309 return NewJniFilter(env, filter);

310 }

311 CATCH_THROW_AND_RETURN(env, 0)

312 }

313

314 static void JavaStringArrayToStringVector(JNIEnv* env, jobjectArray jArray,

315 std::vector<std::string>& out)

316 {

317 if (jArray)

318 {

319 jsize len = env->GetArrayLength(jArray);

320

321 for (jsize i = 0; i < len; i++)

322 {

323 out.push_back(

324 JniJavaToStdString(env,

325 *JniLocalReference<jstring>(env,

326 static_cast<jstring>(

327 env->GetObjectArrayElement(jArray, i)))));

328 }

329 }

330 }

331

332 static jobject JNICALL JniMatchesMany(JNIEnv* env, jclass clazz, jlong ptr,

333 jstring jUrl, jobject jContentType, jobjectArray jDocumentUrls)

334 {

335 AdblockPlus::FilterEngine* engine =

336 JniLongToTypePtr<AdblockPlus::FilterEngine>(ptr);

337

338 std::string url = JniJavaToStdString(env, jUrl);

339 AdblockPlus::FilterEngine::ContentType contentType =

340 ConvertContentType(env, jContentType);

341

342 std::vector<std::string> documentUrls;

343 JavaStringArrayToStringVector(env, jDocumentUrls, documentUrls);

344

345 try

346 {

347 AdblockPlus::FilterPtr filter = engine->Matches(url, contentType,

348 documentUrls);

349

350 return NewJniFilter(env, filter);

351 }

352 CATCH_THROW_AND_RETURN(env, 0)

353 }

354

355 static jboolean JNICALL JniIsDocumentWhitelisted(JNIEnv* env, jclass clazz, jlon g ptr,

356 jstring jUrl, jobjectArray jDocumentUrls)

357 {

358 AdblockPlus::FilterEngine* engine =

359 JniLongToTypePtr<AdblockPlus::FilterEngine>(ptr);

360

361 std::string url = JniJavaToStdString(env, jUrl);

362 std::vector<std::string> documentUrls;

363 JavaStringArrayToStringVector(env, jDocumentUrls, documentUrls);

364 try

365 {

366 return engine->IsDocumentWhitelisted(url, documentUrls) ?

367 JNI_TRUE : JNI_FALSE;

368 }

369 CATCH_THROW_AND_RETURN(env, JNI_FALSE)

370 }

371

372 static jboolean JNICALL JniIsElemhideWhitelisted(JNIEnv* env, jclass clazz, jlon g ptr,

373 jstring jUrl, jobjectArray jDocumentUrls)

374 {

375 AdblockPlus::FilterEngine* engine =

376 JniLongToTypePtr<AdblockPlus::FilterEngine>(ptr);

377

378 std::string url = JniJavaToStdString(env, jUrl);

379 std::vector<std::string> documentUrls;

380 JavaStringArrayToStringVector(env, jDocumentUrls, documentUrls);

381 try

382 {

383 return engine->IsElemhideWhitelisted(url, documentUrls) ?

384 JNI_TRUE : JNI_FALSE;

385 }

386 CATCH_THROW_AND_RETURN(env, JNI_FALSE)

387 }

388

389 static jobject JNICALL JniGetPref(JNIEnv* env, jclass clazz, jlong ptr, jstring jPref)

390 {

391 AdblockPlus::FilterEngine* engine = JniLongToTypePtr < AdblockPlus::FilterEngi ne > (ptr);

392

393 std::string pref = JniJavaToStdString(env, jPref);

394

395 try

396 {

397 AdblockPlus::JsValuePtr value = engine->GetPref(pref);

398

399 return NewJniJsValue(env, value);

400 }

401 CATCH_THROW_AND_RETURN(env, 0)

402 }

403

404 static void JNICALL JniSetPref(JNIEnv* env, jclass clazz, jlong ptr, jstring jPr ef, jlong jsValue)

405 {

406 AdblockPlus::FilterEngine* engine = JniLongToTypePtr<AdblockPlus::FilterEngine >(ptr);

407

408 std::string pref = JniJavaToStdString(env, jPref);

409 AdblockPlus::JsValuePtr value = JniGetJsValuePtr(jsValue);

410

411 try

412 {

413 engine->SetPref(pref, value);

414 }

415 CATCH_AND_THROW(env)

416 }

417

418 static JNINativeMethod methods[] =

419 {

420 { (char)"ctor", (char)"(J)J", (void*)JniCtor },

421 { (char)"isFirstRun", (char)"(J)Z", (void*)JniIsFirstRun },

422 { (char)"getFilter", (char)"(JLjava/lang/String;)" TYP("Filter"), (void*)Jni GetFilter },

423 { (char)"getListedFilters", (char)"(J)Ljava/util/List;", (void*)JniGetListed Filters },

424 { (char)"getSubscription", (char)"(JLjava/lang/String;)" TYP("Subscription") , (void*)JniGetSubscription },

425 { (char)"showNextNotification", (char)"(JLjava/lang/String;)V", (void*)JniSh owNextNotification },

426 { (char)"setShowNotificationCallback", (char)"(JJ)V", (void*)JniSetShowNotif icationCallback },

427 { (char)"removeShowNotificationCallback", (char)"(J)V", (void*)JniRemoveShow NotificationCallback },

428 { (char)"getListedSubscriptions", (char)"(J)Ljava/util/List;", (void*)JniGet ListedSubscriptions },

429 { (char)"fetchAvailableSubscriptions", (char)"(J)Ljava/util/List;", (void*)J niFetchAvailableSubscriptions },

430 { (char)"setUpdateAvailableCallback", (char)"(JJ)V", (void*)JniSetUpdateAvai lableCallback },

431 { (char)"removeUpdateAvailableCallback", (char)"(J)V", (void*)JniRemoveUpdat eAvailableCallback },

432 { (char)"setFilterChangeCallback", (char)"(JJ)V", (void*)JniSetFilterChangeC allback },

433 { (char)"removeFilterChangeCallback", (char)"(J)V", (void*)JniRemoveFilterCh angeCallback },

434 { (char)"forceUpdateCheck", (char)"(JJ)V", (void*)JniForceUpdateCheck },

435 { (char)"getElementHidingSelectors", (char)"(JLjava/lang/String;)Ljava/util/ List;", (void*)JniGetElementHidingSelectors },

436 { (char)"matches", (char)"(JLjava/lang/String;" TYP("FilterEngine$ContentTyp e") "Ljava/lang/String;)" TYP("Filter"), (void*)JniMatches },

437 { (char)"matches", (char)"(JLjava/lang/String;" TYP("FilterEngine$ContentTyp e") "[Ljava/lang/String;)" TYP("Filter"), (void*)JniMatchesMany },

438 { (char)"isDocumentWhitelisted", (char)"(JLjava/lang/String;[Ljava/lang/Stri ng;)Z", (void*)JniIsDocumentWhitelisted },

439 { (char)"isElemhideWhitelisted", (char)"(JLjava/lang/String;[Ljava/lang/Stri ng;)Z", (void*)JniIsElemhideWhitelisted },

440 { (char)"getPref", (char)"(JLjava/lang/String;)" TYP("JsValue"), (void*)JniG etPref },

441 { (char)"setPref", (char)"(JLjava/lang/String;J)V", (void*)JniSetPref },

442 { (char)"dtor", (char)"(J)V", (void*)JniDtor }

443 };

444

445 extern "C" JNIEXPORT void JNICALL Java_org_adblockplus_libadblockplus_FilterEngi ne_registerNatives(JNIEnv *env, jclass clazz)

446 {

447 env->RegisterNatives(clazz, methods, sizeof(methods) / sizeof(methods[0]));

448 }

OLD	NEW

« dependencies ('K') | « jni/JniFilterChangeCallback.cpp ('k') | jni/JniJsEngine.cpp » ('j') | no next file with comments »