yandexads-flutter

1
// Autogenerated from Pigeon (v17.0.0), do not edit directly.
2
// See also: https://pub.dev/packages/pigeon
3
// ignore_for_file: public_member_api_docs, non_constant_identifier_names, avoid_as, unused_import, unnecessary_parenthesis, prefer_null_aware_operators, omit_local_variable_types, unused_shown_name, unnecessary_import, no_leading_underscores_for_local_identifiers
4

5
import 'dart:async';
6
import 'dart:typed_data' show Float64List, Int32List, Int64List, Uint8List;
7

8
import 'package:flutter/foundation.dart' show ReadBuffer, WriteBuffer;
9
import 'package:flutter/services.dart';
10

11
PlatformException _createConnectionError(String channelName) {
12
  return PlatformException(
13
    code: 'channel-error',
14
    message: 'Unable to establish connection on channel: "$channelName".',
15
  );
16
}
17

18
List<Object?> wrapResponse({Object? result, PlatformException? error, bool empty = false}) {
19
  if (empty) {
20
    return <Object?>[];
21
  }
22
  if (error == null) {
23
    return <Object?>[result];
24
  }
25
  return <Object?>[error.code, error.message, error.details];
26
}
27

28
class RewardedError {
29
  RewardedError({
30
    required this.code,
31
    required this.description,
32
  });
33

34
  int code;
35

36
  String description;
37

38
  Object encode() {
39
    return <Object?>[
40
      code,
41
      description,
42
    ];
43
  }
44

45
  static RewardedError decode(Object result) {
46
    result as List<Object?>;
47
    return RewardedError(
48
      code: result[0]! as int,
49
      description: result[1]! as String,
50
    );
51
  }
52
}
53

54
class RewardedImpression {
55
  RewardedImpression({
56
    required this.data,
57
  });
58

59
  String data;
60

61
  Object encode() {
62
    return <Object?>[
63
      data,
64
    ];
65
  }
66

67
  static RewardedImpression decode(Object result) {
68
    result as List<Object?>;
69
    return RewardedImpression(
70
      data: result[0]! as String,
71
    );
72
  }
73
}
74

75
class RewardedEvent {
76
  RewardedEvent({
77
    required this.amount,
78
    required this.type,
79
  });
80

81
  int amount;
82

83
  String type;
84

85
  Object encode() {
86
    return <Object?>[
87
      amount,
88
      type,
89
    ];
90
  }
91

92
  static RewardedEvent decode(Object result) {
93
    result as List<Object?>;
94
    return RewardedEvent(
95
      amount: result[0]! as int,
96
      type: result[1]! as String,
97
    );
98
  }
99
}
100

101
class YandexAdsRewarded {
102
  /// Constructor for [YandexAdsRewarded].  The [binaryMessenger] named argument is
103
  /// available for dependency injection.  If it is left null, the default
104
  /// BinaryMessenger will be used which routes to the host platform.
105
  YandexAdsRewarded({BinaryMessenger? binaryMessenger})
106
      : __pigeon_binaryMessenger = binaryMessenger;
107
  final BinaryMessenger? __pigeon_binaryMessenger;
108

109
  static const MessageCodec<Object?> pigeonChannelCodec = StandardMessageCodec();
110

111
  Future<void> make(String id) async {
112
    const String __pigeon_channelName = 'dev.flutter.pigeon.flutter_yandex_ads.YandexAdsRewarded.make';
113
    final BasicMessageChannel<Object?> __pigeon_channel = BasicMessageChannel<Object?>(
114
      __pigeon_channelName,
115
      pigeonChannelCodec,
116
      binaryMessenger: __pigeon_binaryMessenger,
117
    );
118
    final List<Object?>? __pigeon_replyList =
119
        await __pigeon_channel.send(<Object?>[id]) as List<Object?>?;
120
    if (__pigeon_replyList == null) {
121
      throw _createConnectionError(__pigeon_channelName);
122
    } else if (__pigeon_replyList.length > 1) {
123
      throw PlatformException(
124
        code: __pigeon_replyList[0]! as String,
125
        message: __pigeon_replyList[1] as String?,
126
        details: __pigeon_replyList[2],
127
      );
128
    } else {
129
      return;
130
    }
131
  }
132

133
  Future<void> load(String id) async {
134
    const String __pigeon_channelName = 'dev.flutter.pigeon.flutter_yandex_ads.YandexAdsRewarded.load';
135
    final BasicMessageChannel<Object?> __pigeon_channel = BasicMessageChannel<Object?>(
136
      __pigeon_channelName,
137
      pigeonChannelCodec,
138
      binaryMessenger: __pigeon_binaryMessenger,
139
    );
140
    final List<Object?>? __pigeon_replyList =
141
        await __pigeon_channel.send(<Object?>[id]) as List<Object?>?;
142
    if (__pigeon_replyList == null) {
143
      throw _createConnectionError(__pigeon_channelName);
144
    } else if (__pigeon_replyList.length > 1) {
145
      throw PlatformException(
146
        code: __pigeon_replyList[0]! as String,
147
        message: __pigeon_replyList[1] as String?,
148
        details: __pigeon_replyList[2],
149
      );
150
    } else {
151
      return;
152
    }
153
  }
154

155
  Future<void> show(String id) async {
156
    const String __pigeon_channelName = 'dev.flutter.pigeon.flutter_yandex_ads.YandexAdsRewarded.show';
157
    final BasicMessageChannel<Object?> __pigeon_channel = BasicMessageChannel<Object?>(
158
      __pigeon_channelName,
159
      pigeonChannelCodec,
160
      binaryMessenger: __pigeon_binaryMessenger,
161
    );
162
    final List<Object?>? __pigeon_replyList =
163
        await __pigeon_channel.send(<Object?>[id]) as List<Object?>?;
164
    if (__pigeon_replyList == null) {
165
      throw _createConnectionError(__pigeon_channelName);
166
    } else if (__pigeon_replyList.length > 1) {
167
      throw PlatformException(
168
        code: __pigeon_replyList[0]! as String,
169
        message: __pigeon_replyList[1] as String?,
170
        details: __pigeon_replyList[2],
171
      );
172
    } else {
173
      return;
174
    }
175
  }
176
}
177

178
class _FlutterYandexAdsRewardedCodec extends StandardMessageCodec {
179
  const _FlutterYandexAdsRewardedCodec();
180
  @override
181
  void writeValue(WriteBuffer buffer, Object? value) {
182
    if (value is RewardedError) {
183
      buffer.putUint8(128);
184
      writeValue(buffer, value.encode());
185
    } else if (value is RewardedEvent) {
186
      buffer.putUint8(129);
187
      writeValue(buffer, value.encode());
188
    } else if (value is RewardedImpression) {
189
      buffer.putUint8(130);
190
      writeValue(buffer, value.encode());
191
    } else {
192
      super.writeValue(buffer, value);
193
    }
194
  }
195

196
  @override
197
  Object? readValueOfType(int type, ReadBuffer buffer) {
198
    switch (type) {
199
      case 128: 
200
        return RewardedError.decode(readValue(buffer)!);
201
      case 129: 
202
        return RewardedEvent.decode(readValue(buffer)!);
203
      case 130: 
204
        return RewardedImpression.decode(readValue(buffer)!);
205
      default:
206
        return super.readValueOfType(type, buffer);
207
    }
208
  }
209
}
210

211
abstract class FlutterYandexAdsRewarded {
212
  static const MessageCodec<Object?> pigeonChannelCodec = _FlutterYandexAdsRewardedCodec();
213

214
  void onAdLoaded(String id);
215

216
  void onAdFailedToLoad(String id, RewardedError err);
217

218
  void onAdFailedToShow(String id, RewardedError err);
219

220
  void onAdShown(String id);
221

222
  void onAdDismissed(String id);
223

224
  void onAdClicked(String id);
225

226
  void onImpression(String id, RewardedImpression data);
227

228
  void onRewarded(String id, RewardedEvent reward);
229

230
  static void setup(FlutterYandexAdsRewarded? api, {BinaryMessenger? binaryMessenger}) {
231
    {
232
      final BasicMessageChannel<Object?> __pigeon_channel = BasicMessageChannel<Object?>(
233
          'dev.flutter.pigeon.flutter_yandex_ads.FlutterYandexAdsRewarded.onAdLoaded', pigeonChannelCodec,
234
          binaryMessenger: binaryMessenger);
235
      if (api == null) {
236
        __pigeon_channel.setMessageHandler(null);
237
      } else {
238
        __pigeon_channel.setMessageHandler((Object? message) async {
239
          assert(message != null,
240
          'Argument for dev.flutter.pigeon.flutter_yandex_ads.FlutterYandexAdsRewarded.onAdLoaded was null.');
241
          final List<Object?> args = (message as List<Object?>?)!;
242
          final String? arg_id = (args[0] as String?);
243
          assert(arg_id != null,
244
              'Argument for dev.flutter.pigeon.flutter_yandex_ads.FlutterYandexAdsRewarded.onAdLoaded was null, expected non-null String.');
245
          try {
246
            api.onAdLoaded(arg_id!);
247
            return wrapResponse(empty: true);
248
          } on PlatformException catch (e) {
249
            return wrapResponse(error: e);
250
          }          catch (e) {
251
            return wrapResponse(error: PlatformException(code: 'error', message: e.toString()));
252
          }
253
        });
254
      }
255
    }
256
    {
257
      final BasicMessageChannel<Object?> __pigeon_channel = BasicMessageChannel<Object?>(
258
          'dev.flutter.pigeon.flutter_yandex_ads.FlutterYandexAdsRewarded.onAdFailedToLoad', pigeonChannelCodec,
259
          binaryMessenger: binaryMessenger);
260
      if (api == null) {
261
        __pigeon_channel.setMessageHandler(null);
262
      } else {
263
        __pigeon_channel.setMessageHandler((Object? message) async {
264
          assert(message != null,
265
          'Argument for dev.flutter.pigeon.flutter_yandex_ads.FlutterYandexAdsRewarded.onAdFailedToLoad was null.');
266
          final List<Object?> args = (message as List<Object?>?)!;
267
          final String? arg_id = (args[0] as String?);
268
          assert(arg_id != null,
269
              'Argument for dev.flutter.pigeon.flutter_yandex_ads.FlutterYandexAdsRewarded.onAdFailedToLoad was null, expected non-null String.');
270
          final RewardedError? arg_err = (args[1] as RewardedError?);
271
          assert(arg_err != null,
272
              'Argument for dev.flutter.pigeon.flutter_yandex_ads.FlutterYandexAdsRewarded.onAdFailedToLoad was null, expected non-null RewardedError.');
273
          try {
274
            api.onAdFailedToLoad(arg_id!, arg_err!);
275
            return wrapResponse(empty: true);
276
          } on PlatformException catch (e) {
277
            return wrapResponse(error: e);
278
          }          catch (e) {
279
            return wrapResponse(error: PlatformException(code: 'error', message: e.toString()));
280
          }
281
        });
282
      }
283
    }
284
    {
285
      final BasicMessageChannel<Object?> __pigeon_channel = BasicMessageChannel<Object?>(
286
          'dev.flutter.pigeon.flutter_yandex_ads.FlutterYandexAdsRewarded.onAdFailedToShow', pigeonChannelCodec,
287
          binaryMessenger: binaryMessenger);
288
      if (api == null) {
289
        __pigeon_channel.setMessageHandler(null);
290
      } else {
291
        __pigeon_channel.setMessageHandler((Object? message) async {
292
          assert(message != null,
293
          'Argument for dev.flutter.pigeon.flutter_yandex_ads.FlutterYandexAdsRewarded.onAdFailedToShow was null.');
294
          final List<Object?> args = (message as List<Object?>?)!;
295
          final String? arg_id = (args[0] as String?);
296
          assert(arg_id != null,
297
              'Argument for dev.flutter.pigeon.flutter_yandex_ads.FlutterYandexAdsRewarded.onAdFailedToShow was null, expected non-null String.');
298
          final RewardedError? arg_err = (args[1] as RewardedError?);
299
          assert(arg_err != null,
300
              'Argument for dev.flutter.pigeon.flutter_yandex_ads.FlutterYandexAdsRewarded.onAdFailedToShow was null, expected non-null RewardedError.');
301
          try {
302
            api.onAdFailedToShow(arg_id!, arg_err!);
303
            return wrapResponse(empty: true);
304
          } on PlatformException catch (e) {
305
            return wrapResponse(error: e);
306
          }          catch (e) {
307
            return wrapResponse(error: PlatformException(code: 'error', message: e.toString()));
308
          }
309
        });
310
      }
311
    }
312
    {
313
      final BasicMessageChannel<Object?> __pigeon_channel = BasicMessageChannel<Object?>(
314
          'dev.flutter.pigeon.flutter_yandex_ads.FlutterYandexAdsRewarded.onAdShown', pigeonChannelCodec,
315
          binaryMessenger: binaryMessenger);
316
      if (api == null) {
317
        __pigeon_channel.setMessageHandler(null);
318
      } else {
319
        __pigeon_channel.setMessageHandler((Object? message) async {
320
          assert(message != null,
321
          'Argument for dev.flutter.pigeon.flutter_yandex_ads.FlutterYandexAdsRewarded.onAdShown was null.');
322
          final List<Object?> args = (message as List<Object?>?)!;
323
          final String? arg_id = (args[0] as String?);
324
          assert(arg_id != null,
325
              'Argument for dev.flutter.pigeon.flutter_yandex_ads.FlutterYandexAdsRewarded.onAdShown was null, expected non-null String.');
326
          try {
327
            api.onAdShown(arg_id!);
328
            return wrapResponse(empty: true);
329
          } on PlatformException catch (e) {
330
            return wrapResponse(error: e);
331
          }          catch (e) {
332
            return wrapResponse(error: PlatformException(code: 'error', message: e.toString()));
333
          }
334
        });
335
      }
336
    }
337
    {
338
      final BasicMessageChannel<Object?> __pigeon_channel = BasicMessageChannel<Object?>(
339
          'dev.flutter.pigeon.flutter_yandex_ads.FlutterYandexAdsRewarded.onAdDismissed', pigeonChannelCodec,
340
          binaryMessenger: binaryMessenger);
341
      if (api == null) {
342
        __pigeon_channel.setMessageHandler(null);
343
      } else {
344
        __pigeon_channel.setMessageHandler((Object? message) async {
345
          assert(message != null,
346
          'Argument for dev.flutter.pigeon.flutter_yandex_ads.FlutterYandexAdsRewarded.onAdDismissed was null.');
347
          final List<Object?> args = (message as List<Object?>?)!;
348
          final String? arg_id = (args[0] as String?);
349
          assert(arg_id != null,
350
              'Argument for dev.flutter.pigeon.flutter_yandex_ads.FlutterYandexAdsRewarded.onAdDismissed was null, expected non-null String.');
351
          try {
352
            api.onAdDismissed(arg_id!);
353
            return wrapResponse(empty: true);
354
          } on PlatformException catch (e) {
355
            return wrapResponse(error: e);
356
          }          catch (e) {
357
            return wrapResponse(error: PlatformException(code: 'error', message: e.toString()));
358
          }
359
        });
360
      }
361
    }
362
    {
363
      final BasicMessageChannel<Object?> __pigeon_channel = BasicMessageChannel<Object?>(
364
          'dev.flutter.pigeon.flutter_yandex_ads.FlutterYandexAdsRewarded.onAdClicked', pigeonChannelCodec,
365
          binaryMessenger: binaryMessenger);
366
      if (api == null) {
367
        __pigeon_channel.setMessageHandler(null);
368
      } else {
369
        __pigeon_channel.setMessageHandler((Object? message) async {
370
          assert(message != null,
371
          'Argument for dev.flutter.pigeon.flutter_yandex_ads.FlutterYandexAdsRewarded.onAdClicked was null.');
372
          final List<Object?> args = (message as List<Object?>?)!;
373
          final String? arg_id = (args[0] as String?);
374
          assert(arg_id != null,
375
              'Argument for dev.flutter.pigeon.flutter_yandex_ads.FlutterYandexAdsRewarded.onAdClicked was null, expected non-null String.');
376
          try {
377
            api.onAdClicked(arg_id!);
378
            return wrapResponse(empty: true);
379
          } on PlatformException catch (e) {
380
            return wrapResponse(error: e);
381
          }          catch (e) {
382
            return wrapResponse(error: PlatformException(code: 'error', message: e.toString()));
383
          }
384
        });
385
      }
386
    }
387
    {
388
      final BasicMessageChannel<Object?> __pigeon_channel = BasicMessageChannel<Object?>(
389
          'dev.flutter.pigeon.flutter_yandex_ads.FlutterYandexAdsRewarded.onImpression', pigeonChannelCodec,
390
          binaryMessenger: binaryMessenger);
391
      if (api == null) {
392
        __pigeon_channel.setMessageHandler(null);
393
      } else {
394
        __pigeon_channel.setMessageHandler((Object? message) async {
395
          assert(message != null,
396
          'Argument for dev.flutter.pigeon.flutter_yandex_ads.FlutterYandexAdsRewarded.onImpression was null.');
397
          final List<Object?> args = (message as List<Object?>?)!;
398
          final String? arg_id = (args[0] as String?);
399
          assert(arg_id != null,
400
              'Argument for dev.flutter.pigeon.flutter_yandex_ads.FlutterYandexAdsRewarded.onImpression was null, expected non-null String.');
401
          final RewardedImpression? arg_data = (args[1] as RewardedImpression?);
402
          assert(arg_data != null,
403
              'Argument for dev.flutter.pigeon.flutter_yandex_ads.FlutterYandexAdsRewarded.onImpression was null, expected non-null RewardedImpression.');
404
          try {
405
            api.onImpression(arg_id!, arg_data!);
406
            return wrapResponse(empty: true);
407
          } on PlatformException catch (e) {
408
            return wrapResponse(error: e);
409
          }          catch (e) {
410
            return wrapResponse(error: PlatformException(code: 'error', message: e.toString()));
411
          }
412
        });
413
      }
414
    }
415
    {
416
      final BasicMessageChannel<Object?> __pigeon_channel = BasicMessageChannel<Object?>(
417
          'dev.flutter.pigeon.flutter_yandex_ads.FlutterYandexAdsRewarded.onRewarded', pigeonChannelCodec,
418
          binaryMessenger: binaryMessenger);
419
      if (api == null) {
420
        __pigeon_channel.setMessageHandler(null);
421
      } else {
422
        __pigeon_channel.setMessageHandler((Object? message) async {
423
          assert(message != null,
424
          'Argument for dev.flutter.pigeon.flutter_yandex_ads.FlutterYandexAdsRewarded.onRewarded was null.');
425
          final List<Object?> args = (message as List<Object?>?)!;
426
          final String? arg_id = (args[0] as String?);
427
          assert(arg_id != null,
428
              'Argument for dev.flutter.pigeon.flutter_yandex_ads.FlutterYandexAdsRewarded.onRewarded was null, expected non-null String.');
429
          final RewardedEvent? arg_reward = (args[1] as RewardedEvent?);
430
          assert(arg_reward != null,
431
              'Argument for dev.flutter.pigeon.flutter_yandex_ads.FlutterYandexAdsRewarded.onRewarded was null, expected non-null RewardedEvent.');
432
          try {
433
            api.onRewarded(arg_id!, arg_reward!);
434
            return wrapResponse(empty: true);
435
          } on PlatformException catch (e) {
436
            return wrapResponse(error: e);
437
          }          catch (e) {
438
            return wrapResponse(error: PlatformException(code: 'error', message: e.toString()));
439
          }
440
        });
441
      }
442
    }
443
  }
444
}
445