ECUnionSDK接入文档(1.0.12)

接入方只需要接好接口，SDK要我方二次打包后才会生效。

1.说明

1
2
3
4
1.当你检查确认接入无误后（确认接口有调用到），将接好包体传给我方人员。
2.接入方不需要考虑应用权限适配，SDK内部逻辑已经适配处理
3.一个广告位id对应一个广告实例。不可以一个广告实例使用多个广告位id。
4.类文件所在路径不要使用包名作为路径，因为在二次打包时修改包名会出问题。比如包名为com.aaa.bbb、类名为MainActivtiy.java。类路径就不能为com.aaa.bbb.MainActivtiy.java。如果出现该情况，请重新命名路径。

2.搭建开发环境 (SDK环境搭建二选一即可)

2.1 SDK本地搭建方式 (方式一)

1)拷贝libs目录的SDK文件到您项目的libs目录下。

2)配置AndroidManifest.xml

2.1)添加权限

1
2
3
4
5
6
<uses-permission android:name="android.permission.ACCESS_WIFI_STATE"/>
<uses-permission android:name="android.permission.INTERNET"/>
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE"/>
<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>
<uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE"/>
<uses-permission android:name="android.permission.READ_PHONE_STATE"/>

3)请务必确保工程的模块级build.gradle文件里的包含以下依赖：

1
2
3
4
5
6
7
8
dependencies {
    //引入sdk依赖
    implementation 'com.android.support:appcompat-v7:28.0.0'
    implementation 'com.android.support.constraint:constraint-layout:1.1.3'
    implementation 'com.android.support:design:28.0.0'
	implementation 'com.android.support:recyclerview-v7:28.0.0'
    implementation 'pl.droidsonroids.gif:android-gif-drawable:1.2.18'
}

4)请在AndroidManifest在application的标签中给游戏加上硬件加速：如

1
2
3
4
<application
        android:hardwareAccelerated="true">
        ...
</application>

5)minSdkVersion最小值需要19以上。

2.2 SDK远程仓库搭建方式（方式二 – 推荐）

步骤1: 在项目的根build.gradle中，找到对应标签标签，添加远程库地址

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
allprojects {
    repositories {
        mavenLocal()
        maven{ url 'https://maven.aliyun.com/repository/jcenter'}
        maven{ url 'https://maven.aliyun.com/repository/google'}
        maven { url 'https://maven.aliyun.com/repository/public' }
        mavenCentral()
        maven { url 'https://jitpack.io' }
    }
}

buildscript {
    repositories {
        mavenLocal()
        maven{ url 'https://maven.aliyun.com/repository/jcenter'}
        maven{ url 'https://maven.aliyun.com/repository/google'}
        maven { url 'https://maven.aliyun.com/repository/public' }
        mavenCentral()
    }
}

步骤2:找到游戏导出的游戏模块工程，找到对应的模块build.gradle,找到对应的标签，添加依赖

1
2
3
4
5
6
 dependencies {
	
implementation 'com.github.MarsSDKDev:ECUnionSDK:1.0.12' //这行是SDK的依赖，有更新的时候，会通知更改版本号即可。
implementation 'com.github.MarsSDKDev:ECUnionSDKHelper:0.0.8'//这行是辅助测试的模块，加入后可以有测试广告呼出，运营人员需要出母包的时候，!!!记得把这行注释!!!

}

完成环境的搭建后，在android studio中同步项目(android studio工具栏中有有一个’Sync Project’的按钮,点击一下即可)
再次提醒，出母包的时候，需要把测试模块注释，以免造成来回出包

3.1 SDK的Application初始化（必接）

ECUnionSDK类:

方法名 说明
public static void attachBaseContext(Application application) SDK初始化，在Application子类的attachBaseContext方法中调用,传入application
public static void onApplicationCreate(Application application) SDK初始化，在Application子类的onApplicationCreate方法中调用,传入application 
1
2
3
4
自定义您的Application，调用示例如下:
注意：
接口调用的位置不能错。
要在Androidmanifest里的application标签的android:name属性设置该类，否则该类不被使用。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

import android.app.Application;
import android.content.Context;

import com.ec.union.ecu.pub.ECUnionSDK;

//注意：要在Androidmanifest里的application标签的android:name属性设置该类，否则该类不被使用。
public class GameApp extends Application {

    @Override
    protected void attachBaseContext(Context base) {
        super.attachBaseContext(base);
        //1.application初始化
        ECUnionSDK.attachBaseContext(this);
    }

    @Override
    public void onCreate() {
        super.onCreate();
        //2.application初始化
        ECUnionSDK.onApplicationCreate(this);
    }

}

3.2 SDK主activity初始化（必接）

ECUnionSDK类:

方法名 说明
public static void onMainActivityCreate(Activity activity) 主activity初始化接口
public static void onResume(Activity activity) 当activity在界面上展示时，广告处理相应逻辑
public static void onPause(Activity activity) 当activity失去焦点暂停时，广告处理对应逻辑
public static void onStop(Activity activity) 当activity停止时，广告进行处理相应逻辑
public static void onDestroy(Activity activity) 当activity被销毁时，并回收相应资源
public static void onStart(Activity activity) 当activity启动时，广告进行处理相应逻辑
public static void onRestart(Activity activity) 当activity重新启动时，广告进行处理相应逻辑
public static void onNewIntent(Activity activity) 当activity接受新的intent，广告进行处理相应逻辑
public static void void onActivityResult(Activity activity,int requestCode, int resultCode, Intent data) 进入到权限界面申请权限后返回activity，权限结果回调
public static void onRequestPermissionsResult(Activity activity,int requestCode, String[] permissions, int[] grantResults) 申请权限结果回调 
1
请在应用（游戏）主activity对应的方法里调用SDK接口。

如下所示：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64

public class MainActivity extends Activity {

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        //3.主activity初始化
        ECUnionSDK.onMainActivityCreate(this);
    }

    @Override
    protected void onStart() {
        super.onStart();
        ECUnionSDK.onStart(this);
    }

    @Override
    protected void onRestart() {
        super.onRestart();
        ECUnionSDK.onRestart(this);
    }

    @Override
    protected void onResume() {
        super.onResume();
        ECUnionSDK.onResume(this);
    }

    @Override
    protected void onPause() {
        super.onPause();
        ECUnionSDK.onPause(this);
    }
    @Override
    protected void onStop() {
        super.onStop();
        ECUnionSDK.onStop(this);
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        ECUnionSDK.onDestroy(this);
    }

    @Override
    protected void onNewIntent(Intent intent) {
        super.onNewIntent(intent);
        ECUnionSDK.onNewIntent(this, intent);
    }

    @Override
    protected void onActivityResult(int requestCode, int resultCode, Intent data) {
        super.onActivityResult(requestCode, resultCode, data);
        ECUnionSDK.onActivityResult(this, requestCode, resultCode, data);
    }

    @Override
    public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
        super.onRequestPermissionsResult(requestCode, permissions, grantResults);
        ECUnionSDK.onRequestPermissionsResult(this, requestCode, permissions, grantResults);
    }
}

3.3 开屏广告

ECSplashMgr类:

方法名 说明
public void createSplash(IECAdListener listener) 创建开屏,传入广告侦听器
public void showSplash(String posId) 开屏创建完成后，展示开屏，传入广告位id
public void onCreate(Activity activity, Bundle savedInstanceState) 此activity添加闪屏作为入口activity,初始化广告相关参数
public void onResume() 当activity在界面上展示时，广告处理相应逻辑
public void onPause() 当activity失去焦点暂停时，广告处理对应逻辑
public void onStop() 当activity停止时，广告进行处理相应逻辑
public void onDestroy() 当activity被销毁时，并回收相应资源
public void onStart() 当activity开始时，广告进行处理相应逻辑
public void onRestart() 当activity重新开始时，广告进行处理相应逻辑
public void onNewIntent() 当activity接受新的intent，广告进行处理相应逻辑
public void onSaveInstanceState() 保存activity状态，广告进行处理相应逻辑
public void onConfigurationChanged() 当Configuration发生变化，广告进行处理相应逻辑
public void void onActivityResult(int requestCode, int resultCode, Intent data) 进入到权限界面申请权限后返回activity，权限结果回调
public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) 申请权限结果回调
public boolean onKeyDown(int keyCode, KeyEvent event) 闪屏，屏蔽返回键
public void setSplashEntryClsNm(String className) 在展示之前调用，传入要跳转的activity的全类名 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
注意：
1.闪屏activity必须创建一个单独的activity承托,不能跟应用主activity混在一起，闪屏结束后会自动跳转，接入方不要做跳转操作。
2.闪屏activity在androidmanifest里要指定好方向（横屏或竖屏）。
3.HbSplashMgr.getInstance().setSplashEntryClsNm(); //设置开屏广告结束后要跳转的activity全类名，务必在调用开屏展示接口之前调用。
4.创建的开屏activity要在Androidmanifest里的application标签里注册，否则会出错。
        <activity
            android:name="com.xxx.xxx.GameSplashActivity"
            android:configChanges="keyboard|keyboardHidden|navigation|orientation|screenSize|screenLayout"
            android:screenOrientation="portrait"
            android:theme="@android:style/Theme.NoTitleBar.Fullscreen">

            <!--这个intent-filter表示该activity是启动界面，在Androidmanifest里请保持唯一，不能有多个-->
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>

3.3.1开屏接入方式一：自定义Activity继承ECSplashActivity来展示闪屏。推荐此方式接入闪屏！

示例如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
import android.os.Bundle;
import android.support.annotation.Nullable;
import android.util.Log;

import com.ec.union.ad.sdk.api.ECSplashActivity;
import com.ec.union.ad.sdk.api.ECSplashMgr;
import com.ec.union.ad.sdk.platform.ECAdError;
import com.ec.union.ad.sdk.platform.IECAdListener;

public class GameSplashActivity extends ECSplashActivity{
    private static final String TAG = GameSplashActivity.class.getSimpleName();

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        //展示开屏广告之前,先创建
        ECSplashMgr.getInstance().createSplash(new IECAdListener() {
            @Override
            public void onAdShow() {
                Log.i(TAG, "splash onAdShow");
            }

            @Override
            public void onAdFailed(ECAdError error) {
                Log.i(TAG, "splash onAdFailed: " + error.toString());
            }

            @Override
            public void onAdReady() {
                Log.i(TAG, "splash onAdReady");
            }

            @Override
            public void onAdClick() {
                Log.i(TAG, "splash onAdClick");
            }

            @Override
            public void onAdDismissed() {
                Log.i(TAG, "splash onAdDismissed");
            }

            @Override
            public void onAdReward() {
                Log.i(TAG, "splash onAdReward");
            }
        });

        //设置开屏广告结束后要跳转的activity全类名
        //GameMainActivity.class.getName() MainActivity代指主界面activity。请修改为真正的主activity。
        ECSplashMgr.getInstance().setSplashEntryClsNm(GameMainActivity.class.getName());


        //展示开屏广告
        showSplash();

    }
    private void showSplash() {
        //广告位id,展示广告
        //请填写真正的广告位id
        //AdConstant是用来管理广告位id的。该类可以在demo里找到来使用。
        ECSplashMgr.getInstance().showSplash(AdConstant.SPLASH_ID);
    }
}

3.3.2开屏接入方式二：原生activity中调用闪屏接口展示闪屏

示例如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
public  class GameSplashActivity extends Activity {

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

		//activity初始化
        ECSplashMgr.getInstance().onCreate(this, savedInstanceState);


        //展示开屏广告之前,先创建
        ECSplashMgr.getInstance().createSplash(new IECAdListener() {
            @Override
            public void onAdShow() {
                Log.i(TAG, "splash onAdShow");
            }

            @Override
            public void onAdFailed(ECAdError error) {
                Log.i(TAG, "splash onAdFailed: " + error.toString());
            }

            @Override
            public void onAdReady() {
                Log.i(TAG, "splash onAdReady");
            }

            @Override
            public void onAdClick() {
                Log.i(TAG, "splash onAdClick");
            }

            @Override
            public void onAdDismissed() {
                Log.i(TAG, "splash onAdDismissed");
            }

            @Override
            public void onAdReward() {
                Log.i(TAG, "splash onAdReward");
            }
        });

        //设置开屏广告结束后要跳转的activity全类名
        //GameMainActivity.class.getName() MainActivity代指主界面activity。请修改为真正的主activity。
        ECSplashMgr.getInstance().setSplashEntryClsNm(GameMainActivity.class.getName());


        //展示开屏广告
        showSplash();

    }

    private void showSplash() {
        //广告位id,展示广告
        //请填写真正的广告位id
        ECSplashMgr.getInstance().showSplash(AdConstant.SPLASH_ID);
    }

    @Override
    protected void onResume() {
        super.onResume();
        ECSplashMgr.getInstance().onResume();
    }

    @Override
    protected void onPause() {
        super.onPause();
        ECSplashMgr.getInstance().onPause();
    }

    @Override
    protected void onStop() {
        super.onStop();
        ECSplashMgr.getInstance().onStop();
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        ECSplashMgr.getInstance().onDestroy();
    }

   @Override
    public void onStart() {
       ECSplashMgr.getInstance().onStart();
    }

    @Override
    public void onRestart() {
       ECSplashMgr.getInstance().onRestart();
    }

    @Override
    public void onNewIntent(Intent intent) {
       ECSplashMgr.getInstance().onNewIntent(intent);
    }

    @Override
    public void onSaveInstanceState(Bundle outState) {
       ECSplashMgr.getInstance().onSaveInstanceState(outState);
    }

    @Override
    public void onConfigurationChanged(Configuration newConfig) {
       ECSplashMgr.getInstance().onConfigurationChanged(newConfig);
    }

    @Override
    protected void onActivityResult(int requestCode, int resultCode, Intent data) {
        super.onActivityResult(requestCode, resultCode, data);
        ECSplashMgr.getInstance().onActivityResult(requestCode, resultCode, data);
    }

    @Override
    public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults){
        super.onRequestPermissionsResult(requestCode, permissions, grantResults);
        ECSplashMgr.getInstance().onRequestPermissionsResult(requestCode, permissions, grantResults);
    }

    @Override
    public boolean onKeyDown(int keyCode, KeyEvent event) {
        boolean var = ECSplashMgr.getInstance().onKeyDown(keyCode, event);
        if (!var) {
            return super.onKeyDown(keyCode, event);
        }
        return var;
    }
}

3.4 广告接口

ECAd类

方法名 说明
public ECAd(Activity activity, IECAdListener listener, ECAdType adType) 广告加载类构造函数,传入activity，广告侦听器，广告类型
public void showAd(String posId) 传入广告位id， 展示对应广告类型
public void loadAd(String posId) 传入广告位id，加载视频广告。用于视频类型（FUllVIDEO，REWARDVIDEO）广告的预加载
public void loadAndShowAd(String posId,Map<String,String> param) 此接口只用于激励视频类型，用于服务端发奖励， 传入广告位id，服务端的发奖励参数(在3.6节说明Map参数)
public boolean isReady() 判断视频广告是否加载完成。
public void setVisibility(boolean) 设置广告是否可见，默认为true，true为显示。false为隐藏 。用于feed，infeed和banner类型的广告
public void onResume() 当activity在界面上展示时，广告处理相应逻辑
public void onPause() 当activity失去焦点暂停时，广告处理对应逻辑
public void onStop() 当activity停止时，广告进行处理相应逻辑
public void onDestroy() 当activity被销毁时，清理广告，并回收广告相应资源
public void onStart() 当activity开始时，广告进行处理相应逻辑
public void onRestart() 当activity重新开始时，广告进行处理相应逻辑
public void onNewIntent() 当activity接受新的intent，广告进行处理相应逻辑
public void onSaveInstanceState() 保存activity状态，广告进行处理相应逻辑
public void onConfigurationChanged() 当Configuration发生变化，广告进行处理相应逻辑

3.4.1 广告类型说明

广告类型 说明
ECAdType.BANNER 横幅
ECAdType.INTERSTITIAL 插屏
ECAdType.INFEED 贴片
ECAdType.FEED 信息流
ECAdType.REWARDVIDEO 激励视频
ECAdType.FULLVIDEO 全屏视频

3.5 广告回调接口说明

1
2
3
4
5
6
7
8
9
public interface IECAdListener {
    void onAdShow(); //广告展示时回调
    void onAdFailed(ECAdError error); //失败回调
    void onAdReady();//广告加载准备好回调
    void onAdClick();//点击广告回调
    void onAdDismissed();//关闭广告回调
    void onAdReward();//广告奖励回调，用于视频广告在观看完广告后回调接入方发起奖励给用户
}

3.6 激励视频服务器发奖励接口说明（使用loadAndShowAd接口才接入）

1
2
3
4
5
Map<String,String> gameParams = new HashMap<String,String>();
      gameParams.put(GameParam.REWARD_NAME.getValue(),"五十金币");//奖励名称
      gameParams.put(GameParam.REWARD_AMOUNT.getValue(),"2");//奖励数量
      gameParams.put(GameParam.USER_ID.getValue(),"my_useid");//用户id
      gameParams.put(GameParam.EXTRA.getValue(),"{\"reward_id\":\"8234899234823948394723\"}");//游戏扩展参数，使用json格式传输，包含与服务器约定的参数，请自定义。
1
2
3
注意:
1.示例中的生命周期回调函数请务必调用
2.广告接口请在主activity里使用。

广告接口示例如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634


public class GameMainActivity extends Activity {

    public class AdConstant {
        //请填写真正的广告位id
        //开屏广告位
        public static final String SPLASH_ID = "";
        //插屏广告位
        public static final String INTERSTITIAL_ID = "";
        //banner广告位
        public static final String BANNER_ID = "";
        //激励视频广告位
        public static final String REWARDVIDEO_ID = "";
        //全屏视频广告位
        public static final String FULLVIDEO_ID = "";
        //信息流广告位
        public static final String FEED_ID = "";
        //贴片广告位
        public static final String INFEED_ID = "";
    }


    private static final String TAG = GameMainActivity.class.getSimpleName();
    public static GameMainActivity mGameMainActivity;

    //banner（横幅）广告
    private ECAd bannerAd;
    private boolean mBannerIsShow;

    //插屏广告
    private ECAd interstitialAd;

    //激励视频广告
    private ECAd rewardVideoAd;
    private static long mRewardVideoTime = 0;//记录激励视频当前时间

    //全屏视频广告
    private ECAd fullVideoAd;
    private static long mFullVideoTime = 0;//记录全屏视频当前时间

    //信息流广告
    private ECAd feedAd;
    private boolean mFeedIsShow;

    //贴片广告
    private ECAd infeedAd;
    private boolean mInfeedIsShow;


    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        mGameMainActivity = this;

        //初始化广告实例
        initAd();

    }

    //创建全部广告类型的广告实例
    public void initAd() {
        //banner广告
        if (bannerAd == null) {
            bannerAd = new ECAd(this, new IECAdListener() {
                @Override
                public void onAdShow() {
                    Log.i(TAG, "banner onAdShow");
                }

                @Override
                public void onAdFailed(ECAdError error) {
                    Log.i(TAG, "banner onAdFailed: " + error.toString());
                }

                @Override
                public void onAdReady() {
                    Log.i(TAG, "banner onAdReady");
                    //调用show接口广告加载完成后，根据mBannerIsShow，设置显示或隐藏
                    setBannerShow(mBannerIsShow);
                }

                @Override
                public void onAdClick() {
                    Log.i(TAG, "banner onAdClick");
                }

                @Override
                public void onAdDismissed() {
                    Log.i(TAG, "banner onAdDismissed");
                }

                @Override
                public void onAdReward() {
                    Log.i(TAG, "banner onAdReward");
                }
            }, ECAdType.BANNER);
        }

        //插屏广告
        if (interstitialAd == null) {
            interstitialAd = new ECAd(this, new IECAdListener() {
                @Override
                public void onAdShow() {
                    Log.i(TAG, "interstitial onAdShow");
                }

                @Override
                public void onAdFailed(ECAdError error) {
                    Log.i(TAG, "interstitial onAdFailed: " + error.toString());
                }

                @Override
                public void onAdReady() {
                    Log.i(TAG, "interstitial onAdReady");
                }

                @Override
                public void onAdClick() {
                    Log.i(TAG, "interstitial onAdClick");
                }

                @Override
                public void onAdDismissed() {
                    Log.i(TAG, "interstitial onAdDismissed");
                }

                @Override
                public void onAdReward() {
                    Log.i(TAG, "interstitial onAdReward");
                }
            }, ECAdType.INTERSTITIAL);
        }


        //激励视频广告
        if (rewardVideoAd == null) {
            rewardVideoAd = new ECAd(this, new IECAdListener() {
                @Override
                public void onAdShow() {
                    Log.i(TAG, "rewardVideo onAdShow");
                }

                @Override
                public void onAdFailed(ECAdError error) { //不能在失败回调里调用loadAd，不然很可能会造成死循环。
                    Log.i(TAG, "rewardVideo onAdFailed: " + error.toString());
                }

                @Override
                public void onAdReady() { //视频已经准备好了
                    Log.i(TAG, "rewardVideo onAdReady");
                }

                @Override
                public void onAdClick() {
                    Log.i(TAG, "rewardVideo onAdClick");
                }

                @Override
                public void onAdDismissed() {
                    Log.i(TAG, "rewardVideo onAdDismissed");

                    //关闭广告后重新加载广告
                    if (null != rewardVideoAd) {
                        rewardVideoAd.loadAd(AdConstant.REWARDVIDEO_ID);
                    }

                }

                @Override
                public void onAdReward() {
                    //奖励视频这里发奖励，不要做任何判断，直接在这回调发奖励
                    Log.i(TAG, "rewardVideo onAdReward");
                }
            }, ECAdType.REWARDVIDEO);
        }

        //全屏视频广告
        if (fullVideoAd == null) {
            fullVideoAd = new ECAd(this, new IECAdListener() {
                @Override
                public void onAdShow() {
                    Log.i(TAG, "fullVideo onAdShow");
                }

                @Override
                public void onAdFailed(ECAdError error) { //不能在失败回调里调用loadAd，不然很可能会造成死循环。
                    Log.i(TAG, "fullVideo onAdFailed: " + error.toString());
                }

                @Override
                public void onAdReady() { //视频已经准备好了
                    Log.i(TAG, "fullVideo onAdReady");
                }

                @Override
                public void onAdClick() {
                    Log.i(TAG, "fullVideo onAdClick");
                }

                @Override
                public void onAdDismissed() {
                    Log.i(TAG, "fullVideo onAdDismissed");

                    //关闭广告后重新加载广告
                    if (null != fullVideoAd) {
                        fullVideoAd.loadAd(AdConstant.FULLVIDEO_ID);
                    }

                }

                @Override
                public void onAdReward() {
                    //奖励视频这里发奖励，不要做任何判断，直接在这回调发奖励
                    Log.i(TAG, "rewardVideo onAdReward");
                }
            }, ECAdType.FULLVIDEO);
        }


        //信息流广告
        if (feedAd == null) {
            feedAd = new ECAd(this, new IECAdListener() {
                @Override
                public void onAdShow() {
                    Log.i(TAG, "feed onAdShow");
                }

                @Override
                public void onAdFailed(ECAdError error) {
                    Log.i(TAG, "feed onAdFailed: " + error.toString());

                }

                @Override
                public void onAdReady() {
                    Log.i(TAG, "feed onAdReady");

                    //调用show接口广告加载完成后，根据mFeedIsShow，设置显示或隐藏
                    setFeedShow(mFeedIsShow);
                }

                @Override
                public void onAdClick() {
                    Log.i(TAG, "feed onAdClick");
                }

                @Override
                public void onAdDismissed() {
                    Log.i(TAG, "feed onAdDismissed");
                }

                @Override
                public void onAdReward() {
                    Log.i(TAG, "feed onAdReward");
                }
            }, ECAdType.FEED);
        }


        //贴片广告
        if (infeedAd == null) {
            infeedAd = new ECAd(this, new IECAdListener() {
                @Override
                public void onAdShow() {
                    Log.i(TAG, "infeed onAdShow");
                }

                @Override
                public void onAdFailed(ECAdError error) {
                    Log.i(TAG, "infeed onAdFailed: " + error.toString());
                }

                @Override
                public void onAdReady() {
                    Log.i(TAG, "infeed onAdReady");
                    //调用show接口广告加载完成后，根据mInfeedIsShow，设置显示或隐藏
                    setInfeedShow(mInfeedIsShow);
                }

                @Override
                public void onAdClick() {
                    Log.i(TAG, "infeed onAdClick");
                }

                @Override
                public void onAdDismissed() {
                    Log.i(TAG, "infeed onAdDismissed");
                }

                @Override
                public void onAdReward() {
                    Log.i(TAG, "infeed onAdReward");
                }
            }, ECAdType.INFEED);
        }

    }


    //加载展示信息流广告接口 ，每次showAd调用都会重新加载广告
    public static void showFeedAd() {
        Log.i(TAG, "展示feed广告---->");
        if (null != mGameMainActivity.feedAd) {
            mGameMainActivity.feedAd.showAd(AdConstant.FEED_ID);
        }
    }

    //设置是否显示信息流广告接口
    public static void setFeedShow(boolean isShow) {
        mGameMainActivity.mFeedIsShow = isShow;
        if (null != mGameMainActivity.feedAd) {
            Log.i(TAG, "设置feed广告Visibility：" + isShow);
            mGameMainActivity.feedAd.setVisibility(isShow);//控制feed隐藏显示。
        }
    }


    //加载全屏视频接口，游戏加载完成后只用调用一次
    public static void loadFullVideoAd() {
        //建议接入方在恰当的时机，在游戏层控制调用加载，比如：游戏开始时，进入有视频广告的界面等，按接入方实际情况调用。
        if (null != mGameMainActivity.fullVideoAd) {
            Log.i(TAG, "加载全屏视频广告---->");
            mGameMainActivity.fullVideoAd.loadAd(AdConstant.FULLVIDEO_ID);
        }
    }

    //展示全屏视频广告接口
    public static void showFullVideoAd() {
        if (null != mGameMainActivity.fullVideoAd) {
            if (mGameMainActivity.fullVideoAd.isReady()) { //判断是否加载完毕
                Log.i(TAG, "展示全屏视频广告...");
                mGameMainActivity.fullVideoAd.showAd(AdConstant.FULLVIDEO_ID);//显示视频广告
            } else {
                //接入方也可以在这加载视频广告。但是要限制用户不能频繁点击，加载之间要有一定的时间间隔，视视频大小和网络情况大概在3s~5s。
                Log.i(TAG, "full video ad is not ready");

                long curTime = System.currentTimeMillis();
                boolean isLoad = (0 == mFullVideoTime || curTime - mFullVideoTime > 3000);//3s后可以再加载
                if (isLoad) {//这个是安卓层的防止频繁点击处理。如果接入方在游戏层做了类似的处理，可以将这里的限制注释。
                    mFullVideoTime = curTime;
                    mGameMainActivity.fullVideoAd.loadAd(AdConstant.FULLVIDEO_ID);
                }
            }
        }
    }


    //加载激励视频广告接口，游戏界面加载完成后只用调用一次
    public static void loadRewardVideoAd() {
        //建议接入方在恰当的时机，在游戏层控制调用加载，比如：游戏开始时，进入有视频广告的界面等，按接入方实际情况调用。
        if (null != mGameMainActivity.rewardVideoAd) {
            Log.i(TAG, "加载激励视频广告---->");
            mGameMainActivity.rewardVideoAd.loadAd(AdConstant.REWARDVIDEO_ID);
        }
    }

    //展示激励视频广告接口
    public static void showRewardVideoAd() {
        if (null != mGameMainActivity.rewardVideoAd) {
            if (mGameMainActivity.rewardVideoAd.isReady()) { //判断是否加载完毕
                Log.i(TAG, "展示激励视频广告...");
                mGameMainActivity.rewardVideoAd.showAd(AdConstant.REWARDVIDEO_ID);//显示视频广告
            } else {
                //接入方也可以在这加载视频广告。但是要限制用户不能频繁点击，加载之间要有一定的时间间隔，视视频大小和网络情况大概在3s~5s。
                Log.i(TAG, "reward video ad is not ready");

                long curTime = System.currentTimeMillis();
                boolean isLoad = (0 == mRewardVideoTime || curTime - mRewardVideoTime > 3000);//3s后可以再加载
                if (isLoad) {//这个是安卓层的防止频繁点击处理。如果接入方在游戏层做了类似的处理，可以将这里的限制注释。
                    mRewardVideoTime = curTime;
                    mGameMainActivity.rewardVideoAd.loadAd(AdConstant.REWARDVIDEO_ID);
                }
            }
        }
    }


    //加载展示插屏广告接口
    public static void showInterstitialAd() {
        if (null != mGameMainActivity.interstitialAd) {
            Log.i(TAG, "展示插屏---->");
            mGameMainActivity.interstitialAd.showAd(AdConstant.INTERSTITIAL_ID);
        }
    }


    //加载展示banner广告接口，banner会30s自动刷新
    public static void showBanner() {
        if (null != mGameMainActivity.bannerAd) {
            Log.i(TAG, "展示banner---->");
            mGameMainActivity.bannerAd.showAd(AdConstant.BANNER_ID);
        }
    }

    //因为banner的显示需要网络请求，设置隐藏显示可能无效，所以可以在banner的onReady回调里根据mBannerIsShow设置是否显示
    //设置是否显示banner接口
    public static void setBannerShow(boolean isShow) {
        mGameMainActivity.mBannerIsShow = isShow;
        if (null != mGameMainActivity.bannerAd) {
            Log.i(TAG, "设置banner广告Visibility：" + isShow);
            mGameMainActivity.bannerAd.setVisibility(isShow);
        }
    }

    //加载展示贴片广告接口，每次调用刷新广告
    public static void showInfeedAd() {
        if (null != mGameMainActivity.infeedAd) {
            Log.i(TAG, "展示贴片广告---->");
            mGameMainActivity.infeedAd.showAd(AdConstant.INFEED_ID);
        }
    }

    //设置是否显示的贴片广告接口
    public static void setInfeedShow(boolean isShow) {
        mGameMainActivity.mInfeedIsShow = isShow;
        if (null != mGameMainActivity.infeedAd) {
            Log.i(TAG, "设置infeed广告Visibility：" + isShow);
            mGameMainActivity.infeedAd.setVisibility(isShow);
        }
    }


    @Override
    protected void onStart() {
        super.onStart();
        if (bannerAd != null) {
            bannerAd.onStart();
        }
        if (interstitialAd != null) {
            interstitialAd.onStart();
        }
        if (rewardVideoAd != null) {
            rewardVideoAd.onStart();
        }
        if (fullVideoAd != null) {
            fullVideoAd.onStart();
        }
        if (feedAd != null) {
            feedAd.onStart();
        }
        if (infeedAd != null) {
            infeedAd.onStart();
        }
    }

    @Override
    protected void onRestart() {
        super.onRestart();
        if (bannerAd != null) {
            bannerAd.onRestart();
        }
        if (interstitialAd != null) {
            interstitialAd.onRestart();
        }
        if (rewardVideoAd != null) {
            rewardVideoAd.onRestart();
        }
        if (fullVideoAd != null) {
            fullVideoAd.onRestart();
        }
        if (feedAd != null) {
            feedAd.onRestart();
        }
        if (infeedAd != null) {
            infeedAd.onRestart();
        }
    }

    @Override
    protected void onResume() {
        super.onResume();
        if (bannerAd != null) {
            bannerAd.onResume();
        }
        if (interstitialAd != null) {
            interstitialAd.onResume();
        }
        if (rewardVideoAd != null) {
            rewardVideoAd.onResume();
        }
        if (fullVideoAd != null) {
            fullVideoAd.onResume();
        }
        if (feedAd != null) {
            feedAd.onResume();
        }
        if (infeedAd != null) {
            infeedAd.onResume();
        }
    }

    @Override
    protected void onPause() {
        super.onPause();
        if (bannerAd != null) {
            bannerAd.onPause();
        }
        if (interstitialAd != null) {
            interstitialAd.onPause();
        }
        if (rewardVideoAd != null) {
            rewardVideoAd.onPause();
        }
        if (fullVideoAd != null) {
            fullVideoAd.onPause();
        }
        if (feedAd != null) {
            feedAd.onPause();
        }
        if (infeedAd != null) {
            infeedAd.onPause();
        }
    }

    @Override
    protected void onStop() {
        super.onStop();
        if (bannerAd != null) {
            bannerAd.onStop();
        }
        if (interstitialAd != null) {
            interstitialAd.onStop();
        }
        if (rewardVideoAd != null) {
            rewardVideoAd.onStop();
        }
        if (fullVideoAd != null) {
            fullVideoAd.onStop();
        }
        if (feedAd != null) {
            feedAd.onStop();
        }
        if (infeedAd != null) {
            infeedAd.onStop();
        }
    }

    @Override
    protected void onDestroy() {
        if (bannerAd != null) {
            bannerAd.onDestroy();
        }
        if (interstitialAd != null) {
            interstitialAd.onDestroy();
        }
        if (rewardVideoAd != null) {
            rewardVideoAd.onDestroy();
        }
        if (fullVideoAd != null) {
            fullVideoAd.onDestroy();
        }
        if (feedAd != null) {
            feedAd.onDestroy();
        }
        if (infeedAd != null) {
            infeedAd.onDestroy();
        }
        super.onDestroy();

    }

    @Override
    protected void onNewIntent(Intent intent) {
        super.onNewIntent(intent);
        if (bannerAd != null) {
            bannerAd.onNewIntent(intent);
        }
        if (interstitialAd != null) {
            interstitialAd.onNewIntent(intent);
        }
        if (rewardVideoAd != null) {
            rewardVideoAd.onNewIntent(intent);
        }
        if (fullVideoAd != null) {
            fullVideoAd.onNewIntent(intent);
        }
        if (feedAd != null) {
            feedAd.onNewIntent(intent);
        }
        if (infeedAd != null) {
            infeedAd.onNewIntent(intent);
        }
    }


    @Override
    public void onSaveInstanceState(Bundle outState) {
        super.onSaveInstanceState(outState);
        if (bannerAd != null) {
            bannerAd.onSaveInstanceState(outState);
        }
        if (interstitialAd != null) {
            interstitialAd.onSaveInstanceState(outState);
        }
        if (rewardVideoAd != null) {
            rewardVideoAd.onSaveInstanceState(outState);
        }
        if (fullVideoAd != null) {
            fullVideoAd.onSaveInstanceState(outState);
        }
        if (feedAd != null) {
            feedAd.onSaveInstanceState(outState);
        }
        if (infeedAd != null) {
            infeedAd.onSaveInstanceState(outState);
        }
    }

    @Override
    public void onConfigurationChanged(Configuration newConfig) {
        super.onConfigurationChanged(newConfig);
        if (bannerAd != null) {
            bannerAd.onConfigurationChanged(newConfig);
        }
        if (interstitialAd != null) {
            interstitialAd.onConfigurationChanged(newConfig);
        }
        if (rewardVideoAd != null) {
            rewardVideoAd.onConfigurationChanged(newConfig);
        }
        if (fullVideoAd != null) {
            fullVideoAd.onConfigurationChanged(newConfig);
        }
        if (feedAd != null) {
            feedAd.onConfigurationChanged(newConfig);
        }
        if (infeedAd != null) {
            infeedAd.onConfigurationChanged(newConfig);
        }
    }

}

4 退出接口（必接）

1
在主activity添加以下方法即可。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
@Override
public boolean dispatchKeyEvent(KeyEvent event) {
    if (event.getKeyCode() == KeyEvent.KEYCODE_BACK) {
        if (event.getAction() == KeyEvent.ACTION_DOWN) {
            // SDK退出接口（必接）
            Log.i(TAG, "调用退出接口---->");
            ECUnionSDK.quit(this, new IECQuitResultListener() {

                @Override
                public void onQuit() {
                    //cp 在退出前的额外操作...

                    //游戏退出
                    finish();
                    android.os.Process.killProcess(android.os.Process.myPid());
                    System.exit(0);
                }

                @Override
                public void onCancel() {

                }
            });
            return true;
        }
    }
    return super.dispatchKeyEvent(event);
}

5 登录接口（必接）

1
在主activity添加以下接口使用
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
//登录接口（必接）
public static void login() {
    //请在登录完成后加载进入游戏
    ECUnionSDK.login(mGameMainActivity, new IECELoginResultListener() {
        @Override
        public void onSuccess(UserInfo userInfo) {
            Log.i(TAG, "login onSuccess ");
            //返回的userInfo可能为空，部分SDK没登录功能就直接走成功回调。
            String userId = "";
            String userName = "";
            if (null != userInfo) {
                Log.i(TAG, userInfo.toString());
                if (!TextUtils.isEmpty(userInfo.getUserId())) {
                    userId = userInfo.getUserId();
                }
                if (!TextUtils.isEmpty(userInfo.getUserId())) {
                    userName = userInfo.getUserName();
                }
            }
            //to do..  开始进入游戏。。
        }

        @Override
        public void onFailure(String errMsg) {
            Log.i(TAG, "login onFailure errMsg=" + errMsg);
        }
    });
}

6 支付接口（选接）

1
在主activity添加以下接口使用
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
// 支付接口（选接）
public static void pay() {
    PayInfo payInfo = new PayInfo();
    payInfo.setCpOrderId("";//接入方的订单号，必填。订单号务必保持唯一
    payInfo.setPayCode("");//计费点，必填

    //客户端的支付回调不可靠，有掉单风险。
    ECUnionSDK.pay(mGameMainActivity, payInfo, new IECEPayResultListener() {

        @Override
        public void onSuccess(PaymentResultInfo paymentResultInfo) {
            Log.i(TAG, "pay onSuccess " + paymentResultInfo.toString());

        }

        @Override
        public void onFailure(String errMsg) {
            Log.i(TAG, "pay onFailure errMsg=" + errMsg);
        }

        @Override
        public void onCancel() {

        }
    });

}

7 补单接口（如果有支付必接）

1
在主activity添加以下接口使用
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
//补单接口（如果有支付必接）
public static void checkMissingOrders() {

    ECUnionSDK.checkMissingOrders(mGameMainActivity, new IMissingRewardResultListener() {

        @Override
        public void onSuccess(PaymentResultInfo paymentResultInfo) {
            Log.i(TAG, "checkMissingOrders onSuccess " + paymentResultInfo.toString());
        }

        @Override
        public void onFailure(String errMsg) {
            Log.i(TAG, "checkMissingOrders onFailure errMsg=" + errMsg);
        }
    });

}

8 跳转到特定区域接口，比如：OPPO的超休闲专区（如有要求，请接入）

1
在主activity添加以下接口使用
1
2
3
4
5
//跳转到特定区域接口，比如：OPPO的超休闲专区（如有要求，请接入）
public static void jumpSpecialArea() {
    //只需要在跳转的位置调用即可
    ECUnionSDK.jumpSpecialArea(mGameMainActivity);
}

9 上报用户游戏信息接口（如有要求，请接入）

1
在主activity添加以下接口使用
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
    //上报用户游戏信息接口（如有要求，请接入）
    public static void reportUserGameInfoData() {

//        CP 可在玩家首次成功登陆游戏服务器，并选定游戏角色信息后，调用该接口，上传玩家初始角色
//        信息；为了确保即时性和准确性：
//         1、每次登陆进入游戏之后都要调用接口上报数据；
//         2、当游戏中角色信息任意一个发生变化时要立即调用接口上报数据

        //按游戏实际情况，传入参数
        Map map = new HashMap();
        map.put("roleId", "");//角色id
        map.put("roleName", "");//角色昵称
        map.put("roleLevel", "");//角色等级
        map.put("areaId", "");//区服id
        map.put("areaName", "");//区服名称
        map.put("chapter", "");//关卡章节
        map.put("combatValue", "");//战力值，有战力值的网游必须上传，活动工具需要根据战力值评估
        map.put("pointValue", "");//积分值，捕鱼或棋牌类休闲游戏参与比赛的积分必须上传，如果暂无积分值，游戏可自行设置积分值并上传。
        ECUnionSDK.reportUserGameInfoData(mGameMainActivity, map);
    }

10 自定义计数事件统计接口（选接）

1
2
3
4
在主activity添加以下接口使用。
注意：
自定义事件ID,需要跟后台创建的事件ID一致。
事件ID或者map的key请使用（英文、数字、下划线、中划线、小数点及加号）进行定义，建议加上前缀，防止跟关键字冲突。
1
2
3
4
5
6
7
8
9
10
11
12
13
public static void onEventObject() {

    //事件ID,建议加上前缀，防止跟关键字冲突，需要跟后台创建的事件ID一致。
    String eventId = "";
    //对当前事件的属性描述，定义为“属性名:属性值”的HashMap“<键-值>对”。
    //如果事件不需要属性，传递null即可。(属性值目前仅支持以下数据类型: String，Integer，Long，Short，Float，Double)
    //key建议加上前缀，防止跟关键字冲突。
    Map<String, Object> map = new HashMap<String, Object>();

    //计数事件统计
    ECUnionSDK.onEventObject(mGameMainActivity, eventId, map);

}

11 自定义计算事件统计接口（选接）

1
2
3
4
在主activity添加以下接口使用。
注意：
自定义事件ID,需要跟后台创建的事件ID一致。
事件ID或者map的key请使用（英文、数字、下划线、中划线、小数点及加号）进行定义，建议加上前缀，防止跟关键字冲突。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public static void onEventValue() {

    //事件ID，建议加上前缀，防止跟关键字冲突，需要跟后台创建的事件ID一致。
    String eventId = "";
    //为当前事件的属性和取值（Key-Value键值对），可选，键值的数据类型都是string
    //key建议加上前缀，防止跟关键字冲突。
    Map<String, String> map = new HashMap<String, String>();
    //当前事件的数值，取值范围是-2,147,483,648 到 +2,147,483,647 之间的
    //有符号整数，即int 32类型，如果数据超出了该范围，会造成数据丢包，
    //影响数据统计的准确性。
    int du = 1;

    //计算事件统计
    ECUnionSDK.onEventValue(mGameMainActivity, eventId, map, du);

}

12 自定义计算事件统计接口（选接）

1
2
3
4
在主activity添加以下接口使用。
注意：
自定义事件ID,需要跟后台创建的事件ID一致。
事件ID或者map的key请使用（英文、数字、下划线、中划线、小数点及加号）进行定义，建议加上前缀，防止跟关键字冲突。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public static void onEventValue() {

    //事件ID，建议加上前缀，防止跟关键字冲突，需要跟后台创建的事件ID一致。
    String eventId = "";
    //为当前事件的属性和取值（Key-Value键值对），可选，键值的数据类型都是string
    //key建议加上前缀，防止跟关键字冲突。
    Map<String, String> map = new HashMap<String, String>();
    //当前事件的数值，取值范围是-2,147,483,648 到 +2,147,483,647 之间的
    //有符号整数，即int 32类型，如果数据超出了该范围，会造成数据丢包，
    //影响数据统计的准确性。
    int du = 1;

    //计算事件统计
    ECUnionSDK.onEventValue(mGameMainActivity, eventId, map, du);

}

13 关卡统计接口（选接）

1
2
3
4
5
6
7
在主activity添加以下接口使用。
     * 在游戏开启新的关卡时调用ECUnionSDK.startLevel(level) 方法，
     * 在关卡失败时调用ECUnionSDK.failLevel(level) 方法，
     * 在成功过关时调用ECUnionSDK.finishLevel(level) 方法。
注意：
关卡ID,最好为非空可排序的字符串。(例如：level-01)
目前每个游戏最多支持500个关卡。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
/**
 * 关卡统计接口
 * 在游戏开启新的关卡时调用ECUnionSDK.startLevel(level) 方法，
 * 在关卡失败时调用ECUnionSDK.failLevel(level) 方法，
 * 在成功过关时调用ECUnionSDK.finishLevel(level) 方法。
 * 注意：目前每个游戏最多支持500个关卡。
 * @param level 为关卡ID,最好为非空可排序的字符串。(例如：level-01)
 */
public static void startLevel(String level) {
    ECUnionSDK.startLevel(level);
}
public static void finishLevel(String level) {
    ECUnionSDK.finishLevel(level);
}
public static void failLevel(String level) {
    ECUnionSDK.failLevel(level);
}

14 查询当前的订阅状态接口（需要当前订阅信息时接入）

1
2
3
在主activity添加以下接口使用。
对依赖当期续费情况的业务（比如：视频会员），如果subscriptionInfo.isSubsValid() == true，则应该为用户提供商品对应的服务。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

public static void querySubscriptionStatus() {
    ECUnionSDK.querySubscriptionStatus(mGameMainActivity, new IECQuerySubsResultListener() {
        @Override
        public void onSuccess(List<EPSubscriptionInfo> list) {
            if (null != list) {
                for (int i = 0; i < list.size(); i++) {
                    EPSubscriptionInfo subscriptionInfo = list.get(i);
                    //计费点
                    String payCode = subscriptionInfo.getPayCode();
                    //是否有效。根据这个判断是否提供服务。
                    boolean isSubsValid = subscriptionInfo.isSubsValid();
                    //商品购买时间的时间，UTC时间戳，以毫秒为单位。
                    long purchaseTime = subscriptionInfo.getPurchaseTime();
                    //订阅型商品过期时间的时间，UTC时间戳，以毫秒为单位。
                    //对于一个成功收费的自动续订收据，该时间表示续期日期或者超期日期。
                    // 如果商品最近的收据的该时间是一个过去的时间，则订阅已经过期。
                    long expirationDate = subscriptionInfo.getExpirationDate();

                }
            }

        }

        @Override
        public void onFailure(String msg) {
            Log.i(TAG, msg);
        }
    });
}


15 查询全部订阅记录（包含往期的订阅）接口（需要全部订阅信息时接入）

1
2
3
在主activity添加以下接口使用。
 如果需要往期的续费情况（比如：杂志订阅），根据每个订阅的purchaseTime和expirationDate来判断是否有效。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

    public static void querySubscriptionRecords() {
        ECUnionSDK.querySubscriptionRecords(mGameMainActivity, new IECQuerySubsResultListener() {
            @Override
            public void onSuccess(List<EPSubscriptionInfo> list) {
                if (null != list) {
                    for (int i = 0; i < list.size(); i++) {
                        EPSubscriptionInfo subscriptionInfo = list.get(i);
                        //计费点
                        String payCode = subscriptionInfo.getPayCode();
                        //是否有效 (因为包含过期（往期）的订阅。所以主要是使用purchaseTime和expirationDate来判断是否有效)
//                        boolean isSubsValid = subscriptionInfo.isSubsValid();
                        //商品购买时间的时间，UTC时间戳，以毫秒为单位。
                        long purchaseTime = subscriptionInfo.getPurchaseTime();
                        //订阅型商品过期时间的时间，UTC时间戳，以毫秒为单位。
                        //对于一个成功收费的自动续订收据，该时间表示续期日期或者超期日期。
                        // 如果商品最近的收据的该时间是一个过去的时间，则订阅已经过期。
                        long expirationDate = subscriptionInfo.getExpirationDate();

                    }
                }
            }

            @Override
            public void onFailure(String msg) {
                Log.i(TAG, msg);
            }
        });
    }

16 渠道差异化显示判断

1
用于判断渠道差异化可显示的区域块

1.判断渠道是否允许显示指定区域

1
boolean isShowBlock = ECUnionSDK.isShowBlock();

2.点击区域响应运营自定义弹窗

1
ECUnionSDK.showClDialog();