Android Mobrain SDK——接入说明文档

repositories {
    flatDir {
        dirs 'libs'
    }
}
depedencies {
     //mediation_ad_sdk adapter
    implementation(name: 'admob_adapter', ext: 'aar')
    implementation(name: 'gdt_adapter', ext: 'aar')
    implementation(name: 'unity_adapter', ext: 'aar')
    implementation(name: 'baiduMobAds_adapter', ext: 'aar')
    implementation(name: 'ks_adapter', ext: 'aar')
    implementation(name: 'sigmob_adapter', ext: 'aar')

    //mediation_ad_sdk
    implementation(name: 'mediation_ad_sdk', ext: 'aar')

    //Baidu
    implementation(name: 'Baidu_MobAds_SDK_v5.85', ext: 'aar')

    //unity
    implementation(name: 'unity-ads-android-3.4.2', ext: 'aar')

    //pangle
    implementation(name: 'open_ad_sdk_v2.9.5.8', ext: 'aar')
    
    //GDT
    implementation(name: 'GDTSDK.unionNormal.4.174.1044', ext: 'aar')
    
    //admob
    implementation 'com.google.android.gms:play-services-ads:17.2.0'
    
    //ks 快手
    implementation(name: 'ks_adsdk-2.6.7', ext: 'aar')

    //sigmob
    implementation(name: 'windAd-2.21.0', ext: 'aar')
}

<!--必要权限-->
<uses-permission android:name="android.permission.INTERNET" />
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />

<!--可选权限-->
<uses-permission android:name="android.permission.READ_PHONE_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.ACCESS_WIFI_STATE" />
<uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />
<uses-permission android:name="android.permission.REQUEST_INSTALL_PACKAGES"/>
<uses-permission android:name="android.permission.GET_TASKS"/>
<uses-permission android:name="android.permission.CHANGE_WIFI_STATE" />

<!--可选，Mobrain SDK提供“获取地理位置权限”和“不给予地理位置权限，开发者传入地理位置参数”两种方式上报用户位置，两种方式均可不选，添加位置权限或参数将帮助投放定位广告-->
<!--请注意：无论通过何种方式提供给穿山甲用户地理位置，均需向用户声明地理位置权限将应用于穿山甲广告投放，穿山甲不强制获取地理位置信息-->
<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />

<!-- 如果有视频相关的广告且使用textureView播放，请务必添加，否则黑屏 -->
<uses-permission android:name="android.permission.WAKE_LOCK" />

//建议在广告请求前，合适的时机调用SDK提供的方法（申请权限）
//TTAdsSdk接口中的方法，context可以是Activity或Application
（app中没有）void requestPermissionIfNecessary(Context context);

<!-- Panle  SDK TTFileProvider -->
<provider
    android:name="com.bytedance.sdk.openadsdk.TTFileProvider"
    android:authorities="${applicationId}.TTFileProvider"
    android:exported="false"
    android:grantUriPermissions="true">
   <meta-data
        android:name="android.support.FILE_PROVIDER_PATHS"
        android:resource="@xml/file_paths" />
</provider>

<!-- GDT targetSDKVersion >= 24时才需要添加这个provider。provider的authorities属性的值为${applicationId}.fileprovider，请开发者根据自己的${applicationId}来设置这个值，例如本例中applicationId为"com.qq.e.union.demo"。 -->
<provider
    android:name="android.support.v4.content.FileProvider"
    android:authorities="${applicationId}.fileprovider"
    android:exported="false"
    android:grantUriPermissions="true">
    <meta-data
        android:name="android.support.FILE_PROVIDER_PATHS"
        android:resource="@xml/gdt_file_path" />
 </provider>
 
 <!-- baidu -->
 <provider
             android:name="com.baidu.mobads.openad.BdFileProvider"
             android:authorities="${applicationId}.bd.provider"
             android:exported="false"
             android:grantUriPermissions="true">
             <meta-data
                 android:name="android.support.FILE_PROVIDER_PATHS"
                 android:resource="@xml/bd_file_paths" />
         </provider>

<?xml version="1.0" encoding="utf-8"?>
<paths xmlns:android="http://schemas.android.com/apk/res/android">
   <!--为了适配所有路径可以设置 path = "." -->

   <external-path name="tt_external_root" path="." />
   <external-path name="tt_external_download" path="Download" />
   <external-files-path name="tt_external_files_download" path="Download" />
   <files-path name="tt_internal_file_download" path="Download" />
   <cache-path name="tt_internal_cache_download" path="Download" />
</paths>

<paths>
    <!-- 这个下载路径也不可以修改，必须为com_qq_e_download -->
    <external-cache-path
        name="gdt_sdk_download_path1"
        path="com_qq_e_download" />
    <cache-path
        name="gdt_sdk_download_path2"
        path="com_qq_e_download" />
</paths>

<?xml version="1.0" encoding="utf-8"?>
<paths xmlns:android="http://schemas.android.com/apk/res/android">
     <external-files-path name="bdpath" path="bddownload/" />
     <external-path name="bdpathsd" path="bddownload/" />
</paths>

<paths>
    <!-- 这个下载路径不可以修改，SigDownload -->
    <external-cache-path
        name="SigMob_root"
        path="SigDownload" />
    <external-path
        name="SigMob_root_external"
        path="." />
    <root-path
        name="SigMob_root"
        path="." />
</paths>

<provider
    android:name="com.bytedance.sdk.openadsdk.multipro.TTMultiProvider"
    android:authorities="${applicationId}.TTMultiProvider"
    android:exported="false" />

    <provider
        android:name="com.google.android.gms.ads.MobileAdsInitProvider"
        android:authorities="${applicationId}.mobileadsinitprovider"
        tools:replace="android:authorities" />
    
    <!-- Sample AdMob App ID: ca-app-pub-3940256099942544~3347511713 -->
    <meta-data
        android:name="com.google.android.gms.ads.APPLICATION_ID"
        android:value="ca-app-pub-3940256099942544~3347511713" />
        <!--This meta-data tag is required to use Google Play Services.-->

    <provider
            android:name="com.sigmob.sdk.SigmobFileProvider"
            android:authorities="${applicationId}.sigprovider"
            android:exported="false"
            android:grantUriPermissions="true">
            <meta-data
                android:name="android.support.FILE_PROVIDER_PATHS"
                android:resource="@xml/sigmob_provider_paths" />
        </provider>

        <!-- GDT start================== -->
      
        <activity
            android:name="com.qq.e.ads.PortraitADActivity"
            android:configChanges="keyboard|keyboardHidden|orientation|screenSize"
            android:screenOrientation="portrait" />
        <activity
            android:name="com.qq.e.ads.LandscapeADActivity"
            android:configChanges="keyboard|keyboardHidden|orientation|screenSize"
            android:screenOrientation="landscape" />

        <!-- 声明SDK所需要的组件 -->
        <service
            android:name="com.qq.e.comm.DownloadService"
            android:exported="false" />
        <!-- 请开发者注意字母的大小写，ADActivity，而不是AdActivity -->

        <activity
            android:name="com.qq.e.ads.ADActivity"
            android:configChanges="keyboard|keyboardHidden|orientation|screenSize" />

        <!-- GDT end================== -->

    
        <!-- baidu start================== -->
        <activity
            android:name="com.baidu.mobads.AppActivity"
            android:configChanges="keyboard|keyboardHidden|orientation"
            android:theme="@android:style/Theme.Translucent.NoTitleBar" />
        <!-- baidu end================== -->
        
        <!-- sigmob end================== -->
        <activity
            android:name="com.sigmob.sdk.base.common.AdActivity"
            android:configChanges="keyboardHidden|orientation|screenSize"
            android:theme="@android:style/Theme.DeviceDefault" />
        <!-- sigmob end================== -->

<uses-sdk android:minSdkVersion="14" android:targetSdkVersion="29" />

public class App extends Application {
    @Override
    public void onCreate() {
        super.onCreate();
        TTAdManagerHolder.init(this);  
    }
}

    /**
     * sdk初始化入口
     *
     * @param context 必须是application context
     * @param config  初始化配置信息，必要参数
     */
    public static void initialize(Context context, TTAdConfig config)

    public static class TTAdConfig{
        private String mAppId;// 必选参数，设置应用的AppId
        private String mAppName;// 必选参数，设置应用名称
        private boolean mIsDebug = false;// 可选参数，是否打开debug调试信息输出：true打开、false关闭。默认false关闭
    }

private static TTAdConfig buildConfig() {
        return new TTAdConfig.Builder()
                .appId("5001121")
                .appName("APP测试媒体")
                .isPanglePaid(false)//是否为计费用户(穿山甲SDK相关配置)
                .openDebugLog(true) //测试阶段打开，可以通过日志排查问题，上线时去除该调用
                .usePangleTextureView(true) //使用TextureView控件播放视频,默认为SurfaceView,当有SurfaceView冲突的场景，可以使用TextureView
                .setPangleTitleBarTheme(TTAdConstant.TITLE_BAR_THEME_DARK) //(穿山甲SDK相关配置)
                .allowPangleShowNotify(true) //是否允许sdk展示通知栏提示  (穿山甲SDK相关配置)
                .allowPangleShowPageWhenScreenLock(true) //是否在锁屏场景支持展示广告落地页  (穿山甲SDK相关配置)
                .setPangleDirectDownloadNetworkType(TTAdConstant.NETWORK_STATE_WIFI, TTAdConstant.NETWORK_STATE_3G) //允许直接下载的网络状态集合  (穿山甲SDK相关配置)
                .needPangleClearTaskReset()//特殊机型过滤，部分机型出现包解析失败问题（大部分是三星）。参数取android.os.Build.MODEL   (穿山甲SDK相关配置)
                .build();
    }

     /**
     * 注册config回调 ，当config拉取成功执行回调
     *
     * @param configCallback
     */
    public static void registerConfigCallback(SettingConfigCallback configCallback) {
        
    }

    /**
     * 判断当前是否存在config配置信息
     *
     * @return
     */
    public static boolean configLoadSuccess() {
        
    }

    /**
     * 移除config回调
     *
     * @param configCallback
     */
    public static void unregisterConfigCallback(SettingConfigCallback configCallback) {
        
    }

   /**
     * config回调
     */
    private TTAdsSdk.SettingConfigCallback mSettingConfigCallback = new TTAdsSdk.SettingConfigCallback() {
        @Override
        public void configLoad() {
            Log.e(TAG, "load ad 在config 回调中加载广告");
            loadAd(); //执行广告加载
        }
    };

    private void loadAdWithCallback() {
        /**
         * 判断当前是否存在config 配置 ，如果存在直接加载广告 ，如果不存在则注册config加载回调
         */
        if (TTAdsSdk.configLoadSuccess()) {
            Log.e(TAG, "load ad 当前config配置存在，直接加载广告");
            loadAd();
        } else {
            Log.e(TAG, "load ad 当前config配置不存在，正在请求config配置....");
            TTAdsSdk.registerConfigCallback(mSettingConfigCallback); //不能使用内部类，否则在ondestory中无法移除该回调
        }
    }
    
     @Override
    protected void onDestroy() {
        super.onDestroy();
        //注销config回调
        TTAdsSdk.unregisterConfigCallback(mSettingConfigCallback);
    }

AdSlot adSlot = new AdSlot.Builder()
    // 必选参数 设置广告图片的最大尺寸及期望的图片宽高比，单位Px
    // 注：必填字段，期望的图片尺寸，返回尺寸可能有差异（模板广告需要设置期望个性化模板广告的大小,单位px,代码位是否属于个性化模板广告）
    .setImageAdSize(640, 320)
    // 可选参数 设置是否支持deeplink
    .setSupportDeepLink(true)
    // 可选参数，针对信息流广告设置每次请求的广告返回个数，最多支持3个
    .setAdCount(2)
    //激励视频奖励的名称，针对激励视频参数
    .setRewardName("金币")
    //激励视频奖励个数
    .setRewardAmount(3)
    //用户ID,使用激励视频必传参数
    //表来标识应用侧唯一用户；若非服务器回调模式或不需sdk透传，可设置为空字符串
    .setUserID("user123")
    //设置期望视频播放的方向，为TTAdConstant.HORIZONTAL或TTAdConstant.VERTICAL
    .setOrientation(orientation)
    .build();

public interface TTNativeAd {

    /**
     * 广告标题
     *
     * @return
     */
    String getTitle();

    /**
     * 广告内容描述
     *
     * @return
     */
    String getDescription();

    /**
     * 广告Icon
     *
     * @return
     */
    String getIconUrl();

    /**
     * 大图URL
     *
     * @return
     */
    String getImageUrl();


    /**
     * 大图的宽
     *
     * @return
     */
    int getImageWidth();

    /**
     * 大图的高
     *
     * @return
     */
    int getImageHeight();


    /**
     * 广告按钮文案
     *
     * @return
     */
    String getActionText();

    /**
     * 下载类型广告包名
     *
     * @return
     */
    String getPackageName();

    /**
     * 获取原生view
     */
    View getExpressView();


    /**
     * 广告的下载apk对应的星级
     *
     * @return
     */
    double getStarRating();

    /**
     * 广告图片
     *
     * @return
     */
    List<String> getImageList();


    /**
     * 广告来源，一般是广告主名称
     *
     * @return
     */
    String getSource();


    /**
     * 设置在原生模板广告中使用网盟中dislike
     *
     * @param activity        创建dislike的context
     * @param dislikeCallback dislike选择结果回调
     */
    void setDislikeCallback(Activity activity, TTDislikeCallback dislikeCallback);


    /**
     * 得到dislike dialog 穿山甲SDK使用 原生广告
     *
     * @param activity 建议传当前activity，否则可能会影响dislike对话框弹出
     * @return
     */
    TTAdDislike getDislikeDialog(Activity activity);


    /**
     * 注册点击回调
     *
     * @param nativeAdListener
     */
    void setTTNativeAdListener(TTNativeAdListener nativeAdListener);


    /**
     * 注册视频回调事件
     *
     * @param videoListener
     */
    void setTTVideoListener(TTVideoListener videoListener);

    /**
     * 注册事件，计费点
     *
     * @param container
     * @param clickViews
     * @param creativeViews
     */
    void registerView(@NonNull ViewGroup container, @NonNull List<View> clickViews, @Nullable List<View> creativeViews, TTViewBinder viewBinder);

    /**
     * 解注册
     */
    void unregisterView();

    /**
     * 动态布局渲染时调用的接口，原生广告该接口无效
     */
    void render();

    /**
     * 广告展示类型,大图，小图，组图，视频
     *
     * @return
     */
    int getAdImageMode();

    /**
     * 广告交互类型
     *
     * @return
     */
    int getInteractionType();

    /**
     * 用于判断当前广告是否为模板广告
     *
     * @return
     */
    boolean isExpressAd();

    /**
     * 是否需要dislike 按钮
     *
     * @return
     */
    boolean hasDislike();


    /**
     * 暂停
     */
    void onPause();


    /**
     * onResume
     */
    void resume();

    /**
     * 释放资源
     */
    void destroy();
}

    //step1:创建TTUnifiedNativeAd对象，传递Context对象和广告位ID即mAdUnitId
    TTUnifiedNativeAd  mTTAdNative;
    //....省略其他代码  具体详见demo
    
    
     /**
     * config回调
     */
    private TTAdsSdk.SettingConfigCallback mSettingConfigCallback = new TTAdsSdk.SettingConfigCallback() {
        @Override
        public void configLoad() {
            Log.e(TAG, "load ad 在config 回调中加载广告");
            loadListAd();
        }
    };


    /**
     * 加载feed广告
     */
    private void loadListAdWithCallback() {
        /**
         * 判断当前是否存在config 配置 ，如果存在直接加载广告 ，如果不存在则注册config加载回调
         */
        if (TTAdsSdk.configLoadSuccess()) {
            Log.e(TAG, "load ad 当前config配置存在，直接加载广告");
            loadListAd();
        } else {
            Log.e(TAG, "load ad 当前config配置不存在，正在请求config配置....");
            TTAdsSdk.registerConfigCallback(mSettingConfigCallback); //不能使用内部类，否则在ondestory中无法移除该回调
        }
    }
    
    
    /**
     * 加载feed广告
     */
    private void loadListAd() {

        mTTAdNative = new TTUnifiedNativeAd(this, mAdUnitId);
        //step2:创建feed广告请求类型参数AdSlot,具体参数含义参考文档
        AdSlot adSlot = new AdSlot.Builder()
                .setSupportDeepLink(true)
                .setImageAdSize(640, 320)//注：必填字段，期望的图片尺寸，返回尺寸可能有差异
                .setAdCount(3) //请求广告数量为1到3条
                .build();
        //step3:请求广告，调用feed广告异步请求接口，加载到广告后，拿到广告素材自定义渲染
        mTTAdNative.loadAd(adSlot, new TTNativeAdLoadCallback() {
            @Override
            public void onAdLoaded(List<TTNativeAd> ads) {
                if (ads == null || ads.isEmpty()) {
                    TToast.show(FeedListActivity.this, "on FeedAdLoaded: ad is null!");
                    return;
                }
                //广告加载成功 ads
            }

            @Override
            public void onAdLoadedFial(AdError adError) {
                //广告加载失败
            }
        });
        
    @Override
    protected void onDestroy() {
        super.onDestroy();
        //注销config回调
        TTAdsSdk.unregisterConfigCallback(mSettingConfigCallback);
        
        if (mAds != null) {
            for (TTNativeAd ad : mAds) {
                ad.destroy();
            }
        }
        mAds = null;
    }
        
        
        
        

        //针对广点通的信息流声音单独配置
        GDTExtraOption gdtExtraOption = new GDTExtraOption.Builder()
                .setGDTAutoPlayMuted(true)//自动播放是否静音，默认true
                .setGDTDetailPageMuted(true)//详情页是否静音，默认值为false，即有声播放；
                .setGDTEnableDetailPage(true)//是否能跳转详情页，默认true
                .setGDTEnableUserControl(false)//是否能控制是否暂停与播放，默认false
                .setGDTMaxVideoDuration(15)//视频最大长度，单位:秒 此设置会影响广告填充，请谨慎设置
                .setGDTMinVideoDuration(5)//视频最小长度，单位:秒 此设置会影响广告填充，请谨慎设置
                // VideoOption.AutoPlayPolicy.WIFI表示只在WiFi下自动播放；
                // VideoOption.AutoPlayPolicy.ALWAYS表示始终自动播放，不区分当前网络；
                // VideoOption.AutoPlayPolicy.NEVER表示始终都不自动播放，不区分当前网络，但在WiFi时会预下载视频资源；
                // 默认为始终自动播放；模板渲染视频、插屏视频、自渲染视频都可使用
                .setAutoPlayPolicy(GDTExtraOption.AutoPlayPolicy.WIFI)//自动播放策略--
                .build();

        //针对百度SDK信息流设置
        BaiduExtraOptions baiduExtraOptions = new BaiduExtraOptions.Builder()
                .setGDTExtraOption(BaiduExtraOptions.DOWNLOAD_APP_CONFIRM_ALWAYS)
                .setCacheVideoOnlyWifi(true).build();

        //视频声音控制
        TTVideoOption videoOption = new TTVideoOption.Builder()
                .setMuted(true) //所有类型生效，除GDT
                .setAdmobAppVolume(0f)//针对admob声音配置，与setMuted配合使用，范围[0-1]
                .setGDTExtraOption(gdtExtraOption)//GDT单独配置
                .setBaiduExtraOption(baiduExtraOptions)//百度SDK配置
                .build();

        //创建feed广告请求类型参数AdSlot,具体参数含义参考文档
        AdSlot adSlot = new AdSlot.Builder()
                .setTTVideoOption(videoOption)//视频声音相关的配置
                .setAdStyleType(mAdStyle)//必传，表示请求的模板广告还是原生广告
                .setSupportDeepLink(true)
                .setImageAdSize(640, 320)
                .setAdCount(3) //请求广告数量为1到3条
                .build();

public static final class Builder {
        private boolean mMuted = true; //视频类是否静音
        private float mAdmobAppVolume;//  admob 声音大小的设置 范围[0-1]
        private GDTExtraOption mGDTExtraOption; //广点通信息流和自渲染2.0 以及 插屏2.0 视频配置项

        public Builder() {
        }
        
        /**
         * 广点通广告的自渲染2.0 和 插屏2.0 视频额外配置项
         * @param gdtExtraOption
         */
        public Builder setGDTExtraOption(GDTExtraOption gdtExtraOption) {
            mGDTExtraOption = gdtExtraOption;
            return this;
        }

        /**
         * Admob 声音大小设置,范围：[0-1]
         * the volume as a float from 0 (muted) to 1 (full media volume)
         * @param volume
         */
        public Builder setAdmobAppVolume(float volume) {
            if (volume > 1) {
                volume = 1;
            } else if (volume < 0) {
                volume = 0;
            }
            this.mAdmobAppVolume = volume;
            return this;
        }

        /**
         * 设置视频类广告是否静音 ， true 静音 ， false 非静音
         * @param mMuted
         * @return
         */
        public final Builder setMuted(boolean mMuted) {
            this.mMuted = mMuted;
            return this;
        }

        public final TTVideoOption build() {
            return new TTVideoOption(this);
        }
    }

//视频广告设置播放状态回调（可选）
    ad.setTTVideoListener(new TTVideoListener() {

        @Override
        public void onVideoStart() {
            TToast.show(mContext, "广告视频开始播放");
        }

        @Override
        public void onVideoPause() {
            TToast.show(mContext, "广告视频暂停");
        }

        @Override
        public void onVideoResume() {
            TToast.show(mContext, "广告视频继续播放");
        }

        @Override
        public void onVideoCompleted() {
            TToast.show(mContext, "广告被点击");
        }

        @Override
        public void onVideoError(AdError adError) {
            TToast.show(mContext, "广告视频播放出错");
        }
    });

<?xml version="1.0" encoding="utf-8"?>
<!-- 必须使用SDK提供的TTNativeAdView布局作为广告的父View ，否则将会影响广告点击计费 -->
<com.bytedance.sdk.api.format.TTNativeAdView xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="wrap_content">

    <RelativeLayout
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        tools:ignore="HardcodedText">

        <include
            android:id="@+id/icon_source_layout"
            layout="@layout/listitem_ad_icon_source_layout" />
        <TextView
            android:id="@+id/tv_listitem_ad_desc"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:layout_below="@+id/icon_source_layout"
            android:textSize="18sp" />
        <!--使用SDK提供的视频容器布局-->
        <com.bytedance.sdk.api.format.TTMediaView
            android:id="@+id/iv_listitem_video"
            android:layout_width="match_parent"
            android:layout_height="200dp"
            android:layout_below="@id/tv_listitem_ad_desc"
            android:layout_marginLeft="10dp"
            android:layout_marginRight="10dp"
            android:background="@android:color/background_dark"
            android:scaleType="centerCrop" />

        <!-- title+creativeBtn layout -->
        <include
            android:id="@+id/ad_title_creative_btn_layout"
            layout="@layout/listitem_ad_title_creative_btn_layout"
            android:layout_width="match_parent"
            android:layout_height="45dp"
            android:layout_below="@+id/iv_listitem_video"
            android:layout_marginLeft="10dp"
            android:layout_marginRight="10dp" />

    </RelativeLayout>
</com.bytedance.sdk.api.format.TTNativeAdView>

 private View getVideoView(View convertView, ViewGroup parent, @NonNull final TTNativeAd ad) {
            final VideoAdViewHolder adViewHolder;
            TTViewBinder viewBinder;
            try {
                if (convertView == null) {
                    convertView = LayoutInflater.from(mContext).inflate(R.layout.listitem_ad_large_video, parent, false);
                    adViewHolder = new VideoAdViewHolder();
                    adViewHolder.mTitle = (TextView) convertView.findViewById(R.id.tv_listitem_ad_title);
                    adViewHolder.mDescription = (TextView) convertView.findViewById(R.id.tv_listitem_ad_desc);
                    adViewHolder.mSource = (TextView) convertView.findViewById(R.id.tv_listitem_ad_source);
                    adViewHolder.videoView = (FrameLayout) convertView.findViewById(R.id.iv_listitem_video);
                    adViewHolder.mIcon = (ImageView) convertView.findViewById(R.id.iv_listitem_icon);
                    adViewHolder.mDislike = (ImageView) convertView.findViewById(R.id.iv_listitem_dislike);
                    adViewHolder.mCreativeButton = (Button) convertView.findViewById(R.id.btn_listitem_creative);
                    //TTViewBinder 是必须类,需要开发者在确定好View之后把Id设置给TTViewBinder类，并在注册事件时传递给SDK
                    viewBinder = new TTViewBinder.Builder(R.layout.listitem_ad_large_video).
                            titleId(R.id.tv_listitem_ad_title).
                            sourceId(R.id.tv_listitem_ad_source).
                            decriptionTextId(R.id.tv_listitem_ad_desc).
                            mediaViewIdId(R.id.iv_listitem_video).
                            callToActionId(R.id.btn_listitem_creative).
                            iconImageId(R.id.iv_listitem_icon).build();
                    adViewHolder.viewBinder = viewBinder;
                    convertView.setTag(adViewHolder);
                } else {
                    adViewHolder = (VideoAdViewHolder) convertView.getTag();
                    viewBinder = adViewHolder.viewBinder;
                }
                //绑定广告数据、设置交互回调，同时传递viewBinder对象
                bindData(convertView, adViewHolder, ad, viewBinder);
            } catch (Exception e) {
                e.printStackTrace();
            }

            return convertView;
        }

public final static class Builder {
        /**
         * 广告View的布局文件ID
         */
        private final int layoutId;
        /**
         * 广告标题对应控件的ID
         */
        private int titleId;
        /**
         * 广告描述对应控件的ID
         */
        private int decriptionTextId;
        /**
         * 广告创意按钮(如下载，查看详情等)对应控件的ID
         */
        private int callToActionId;
        /**
         * 广告Icon对应的控件ID
         */
        private int iconImageId;
        /**
         * 广告大图对应控件的ID
         */
        private int mainImageId;
        /**
         * 广告视频对于控件的ID(视频类才需要传递)
         */
        private int mediaViewId;
        /**
         * 广告来源对于控件的ID
         */
        private int sourceId;
}

<?xml version="1.0" encoding="utf-8"?>
<com.bytedance.sdk.api.format.TTNativeAdView xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="wrap_content">

    <FrameLayout
        android:id="@+id/iv_listitem_express"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:layout_gravity="center" />

</com.bytedance.sdk.api.format.TTNativeAdView>

 //渲染模板广告
@SuppressWarnings("RedundantCast")
private View getExpressAdView(View convertView, ViewGroup parent, @NonNull final TTNativeAd ad){
     final ExpressAdViewHolder adViewHolder;
     try {
         if (convertView == null) {
             convertView = LayoutInflater.from(mContext).inflate(R.layout.listitem_ad_native_express, parent, false);
             adViewHolder = new ExpressAdViewHolder();
             adViewHolder.mAdContainerView = (FrameLayout) convertView.findViewById(R.id.iv_listitem_express);
             convertView.setTag(adViewHolder);
         } else {
             adViewHolder = (ExpressAdViewHolder) convertView.getTag();
         }

         //判断是否存在dislike按钮
         if (ad.hasDislike()) {
             ad.setDislikeCallback((Activity) mContext, new TTDislikeCallback() {
                 @Override
                 public void onSelected(int position, String value) {
                     TToast.show(mContext, "点击 " + value);
                     //用户选择不喜欢原因后，移除广告展示
                     mData.remove(ad);
                     sumCount--;
                     notifyDataSetChanged();
                 }

                 @Override
                 public void onCancel() {
                     TToast.show(mContext, "dislike 点击了取消");
                 }
             });
         }

         //设置点击展示回调监听
         ad.setTTNativeAdListener(new TTNativeExpressAdListener() {
             @Override
             public void onAdClick() {
                 TToast.show(mContext, "模板广告被点击");
             }

             @Override
             public void onAdShow() {
                 TToast.show(mContext, "模板广告show");
             }

             @Override
             public void onRenderFail(View view, String msg, int code) {
                 TToast.show(mContext, "模板广告渲染失败code=" + code + ",msg=" + msg);
             }

             @Override
             public void onRenderSuccess(View view, float width, float height) {
                 TToast.show(mContext, "模板广告渲染成功:width=" + width + ",height=" + height);
                 //回调渲染成功后将模板布局添加的父View中
                 if (adViewHolder.mAdContainerView != null) {
                     //获取视频播放view,该view SDK内部渲染，在媒体平台可配置视频是否自动播放等设置。
                     int sWidth;
                     int sHeight;
                     final View video = ad.getExpressView();
                     //如果返回的size是TTAdSize.FULL_WIDTH和 height == TTAdSize.AUTO_HEIGHT
                     //广告view的布局直接设置为如下值
                     if (width == TTAdSize.FULL_WIDTH && height == TTAdSize.AUTO_HEIGHT) {
                         sWidth = FrameLayout.LayoutParams.MATCH_PARENT;
                         sHeight = FrameLayout.LayoutParams.WRAP_CONTENT;
                     } else {
                         //传回来的值，开发者可自行调整View大小
                         sWidth = UIUtils.getScreenWidth(mContext);
                         sHeight = (int) ((sWidth * height) / width);
                     }
                     if (video != null) {
                  
                         if (video.getParent() == null) {
                             FrameLayout.LayoutParams layoutParams = new FrameLayout.LayoutParams(sWidth, sHeight);
                             adViewHolder.mAdContainerView.removeAllViews();
                             adViewHolder.mAdContainerView.addView(video, layoutParams);
                         }
                     }
                 }
             }
         });
         //调用渲染模板布局的方法
         ad.render();
     } catch (Exception e) {
         e.printStackTrace();
     }

     return convertView;
     }

private void bindData(View convertView, final AdViewHolder adViewHolder, final TTNativeAd ad, TTViewBinder viewBinder) {
   //设置dislike弹窗，如果有
   if (ad.hasDislike()) {
       final TTAdDislike ttAdDislike = ad.getDislikeDialog((Activity) mContext);
       adViewHolder.mDislike.setVisibility(View.VISIBLE);
       adViewHolder.mDislike.setOnClickListener(new View.OnClickListener() {
           @Override
           public void onClick(View v) {
               //使用接口来展示
               ttAdDislike.showDislikeDialog();
               ttAdDislike.setDislikeCallback(new TTDislikeCallback() {
                   @Override
                   public void onSelected(int position, String value) {
                       TToast.show(mContext, "点击 " + value);
                       //用户选择不喜欢原因后，移除广告展示
                       mData.remove(ad);
                       sumCount--;//总数也要减少
                       notifyDataSetChanged();
                   }
                   @Override
                   public void onCancel() {
                       TToast.show(mContext, "dislike 点击了取消");
                   }
               });
           }
       });
   } else {
       if (adViewHolder.mDislike != null)
           adViewHolder.mDislike.setVisibility(View.GONE);
   }
   //设置事件回调
   ad.setTTNativeAdListener(mTTNativeAdListener);
   //可以被点击的view, 也可以把convertView放进来意味item可被点击
   List<View> clickViewList = new ArrayList<>();
   clickViewList.add(convertView);
   clickViewList.add(adViewHolder.mSource);
   clickViewList.add(adViewHolder.mTitle);
   clickViewList.add(adViewHolder.mDescription);
   clickViewList.add(adViewHolder.mIcon);
   //触发创意广告的view（点击下载或拨打电话）
   List<View> creativeViewList = new ArrayList<>();
   creativeViewList.add(adViewHolder.mCreativeButton);
   //重要! 这个涉及到广告计费，必须正确调用。convertView必须使用ViewGroup,必须传递viewBinder
   ad.registerView((ViewGroup) convertView, clickViewList, creativeViewList, viewBinder);
   //省略其他代码
}

 public interface  TTNativeAdListener {
    /**
     * 点击回调事件
     */
    void onAdClick();
    
    /**
     * 展示回调事件
     */
    void onAdShow();
}

public interface TTNativeExpressAdListener extends TTNativeAdListener {
     /**
     * 点击回调事件
     */
    void onAdClick();

    /**
     * 展示回调事件
     */
    void onAdShow();
    
    /**
     * 模板渲染失败
     * @param view
     */
    void onRenderFail(View view, String msg, int code);

    /**
     * 模板渲染成功
     * @param view
     * @param width  返回view的宽 ，开发者可以根据返回的宽高进行比例适配
     * @param height 返回view的高 ，开发者可以根据返回的宽高进行比例适配
     */
    void onRenderSuccess(View view, float width, float height);
}

public static final int BANNER_320_50 = 1;
public static final int BANNER_320_100 = 2;
public static final int BANNER_300_250 = 3;
public static final int BANNER_468_60 = 4; 
public static final int BANNER_728_90 = 5;
public static final int BANNER_CUSTOME = 6; //自定义大小

    /**
     * config回调
     */
    private TTAdsSdk.SettingConfigCallback mSettingConfigCallback = new TTAdsSdk.SettingConfigCallback() {
        @Override
        public void configLoad() {
            Log.e(TAG, "load ad 在config 回调中加载广告");
            loadBannerAd();
        }
    };

    /**
     * 加载广告
     */
    private void loadAdWithCallback() {
        /**
         * 判断当前是否存在config 配置 ，如果存在直接加载广告 ，如果不存在则注册config加载回调
         */
        if (TTAdsSdk.configLoadSuccess()) {
            Log.e(TAG, "load ad 当前config配置存在，直接加载广告");
            loadBannerAd();
        } else {
            Log.e(TAG, "load ad 当前config配置不存在，正在请求config配置....");
            TTAdsSdk.registerConfigCallback(mSettingConfigCallback); //不能使用内部类，否则在ondestory中无法移除该回调
        }
    }

private void loadBannerAd(String adUnitId) {
        mTTBannerView = new TTBannerView(this, adUnitId);
        mTTBannerView.setRefreshTime(30);//设置轮播时间30S
        mTTBannerView.setAllowShowCloseBtn(true);//如果广告本身允许展示关闭按钮，这里设置为true 就是展示
        mTTBannerView.setTTAdBannerListener(ttAdBannerListener);
        //step4:创建广告请求参数AdSlot,具体参数含义参考文档
        AdSlot adSlot = new AdSlot.Builder()
                .setSupportDeepLink(true)
                .setBannerSize(TTAdSize.BANNER_320_50)
                //.setBannerSize(300,600) 使用TTAdSize.BANNER_CUSTOME可以调用setAdSize设置大小
                .build();
        //step5:请求广告，对请求回调的广告作渲染处理
        mTTBannerView.loadAd(adSlot, new TTAdBannerLoadCallBack() {
            @Override
            public void onAdFailedToLoad(AdError adError) {
                mBannerContainer.removeAllViews();
            }

            @Override
            public void onAdLoaded() {
                mBannerContainer.removeAllViews();
                if (mTTBannerView != null) {
                    //横幅广告容器的尺寸必须至少与横幅广告一样大。如果您的容器留有内边距，实际上将会减小容器大小。如果容器无法容纳横幅广告，则横幅广告不会展示
                    View view = mTTBannerView.getBannerView();
                    if (view != null)
                        mBannerContainer.addView(view);
                }
            }
        });
    }
    
    
    @Override
    protected void onDestroy() {
        super.onDestroy();
        //注销config回调
        TTAdsSdk.unregisterConfigCallback(mSettingConfigCallback);
        if (mTTBannerView != null) {
            mTTBannerView.destroy();
        }
    }

public interface TTAdBannerListener {

    /**
     * 当广告打开浮层时调用，如打开内置浏览器、内容展示浮层，一般发生在点击之后
     * 常常在onAdLeftApplication之前调用，不能保证每次都回调
     */
    void onAdOpened();

    /**
     * 此方法会在用户点击打开其他应用（例如 Google Play）时
     * 于 onAdOpened() 之后调用，从而在后台运行当前应用，不能保证每次都回调
     */
    void onAdLeftApplication();

    /**
     * 关闭广告
     */
    void onAdClosed();

    /**
     * 广告被点击，肯定有回调
     */
    void onAdClicked();

    /**
     * 广告展示，肯定有回调
     */
    void onAdShow();
}

 mTTSplashAd = new TTSplashAd(this, "801121974");
        mTTSplashAd.setTTAdSplashListener(mSplashAdListener);
        //step3:创建开屏广告请求参数AdSlot,具体参数含义参考文档
        AdSlot adSlot = new AdSlot.Builder()
                .setSupportDeepLink(true)
                .setImageAdSize(1080, 1920)
                .build();
        //step4:请求广告，调用开屏广告异步请求接口，对请求回调的广告作渲染处理
        mTTSplashAd.loadAd(adSlot, new TTSplashAdLoadCallback() {
            @Override
            public void onSplashAdLoadFail(AdError adError) {
                Log.d(TAG, adError.message);
                mHasLoaded = true;
                goToMainActivity();
            }

            @Override
            public void onSplashAdLoadSuccess() {
                if (mTTSplashAd != null) {
                    mTTSplashAd.showAd(mSplashContainer);
                }
            }

            @Override
            public void onAdLoadTimeout() {
                mHasLoaded = true;
                goToMainActivity();
            }
        }, AD_TIME_OUT);

public interface TTSplashAdListener{

    /**
     * Splash广告的点击回调
     */
    void onAdClicked();

    /**
     * Splash广告的展示回调
     */
    void onAdShow();

    /**
     * 点击跳过时回调
     */
    void onAdSkip();

    /**
     * 广告关闭时调用，可能是用户关闭或者展示时间到。
     * 此时一般需要跳过开屏的 Activity，进入应用内容页面
     * 广告播放时间结束 --》onAdDismissed(GDT)
     */
    void onAdDismiss();
}

    

    private TTAdsSdk.SettingConfigCallback mSettingConfigCallback = new TTAdsSdk.SettingConfigCallback() {
        @Override
        public void configLoad() {
            Log.e(TAG, "load ad 在config 回调中加载广告");
            loadInteractionAd();
        }
    };
    

    /**
     * 加载插屏广告
     */
    private void loadAdWithCallback(){
        /**
         * 判断当前是否存在config 配置 ，如果存在直接加载广告 ，如果不存在则注册config加载回调
         */
        if (TTAdsSdk.configLoadSuccess()) {
            Log.e(TAG, "load ad 当前config配置存在，直接加载广告");
            loadInteractionAd();
        } else {
            Log.e(TAG, "load ad 当前config配置不存在，正在请求config配置....");
            TTAdsSdk.registerConfigCallback(mSettingConfigCallback);
        }
    }
    
    
    private void loadInteractionAd(final String adUnitId) {
        //Context 必须传activity
        mInterstitialAd = new TTInterstitialAd(this, adUnitId);

        //创建插屏广告请求参数AdSlot,具体参数含义参考文档
        AdSlot adSlot = new AdSlot.Builder()
                .setSupportDeepLink(true)
                .setImageAdSize(600, 600) //根据广告平台选择的尺寸（目前该比例规格仅对穿山甲SDK生效，插屏广告支持的广告尺寸：  1:1, 3:2, 2:3）
                .build();
        //请求广告，调用插屏广告异步请求接口
        mInterstitialAd.loadAd(adSlot, new TTInterstitialAdLoadCallback() {
            @Override
            public void onInterstitialLoadFail(AdError adError) {
                isLoadSuccess = false;
            }

            @Override
            public void onInterstitialLoad() {
                isLoadSuccess = true;
            }
        });
    }
    
    
    @Override
    protected void onDestroy() {
        super.onDestroy();
        //注销config回调
        TTAdsSdk.unregisterConfigCallback(mSettingConfigCallback);
        if (mInterstitialAd != null) {
            mInterstitialAd.destroy();
        }
    }

if (isLoadSuccess && mInterstitialAd != null && mInterstitialAd.isReady()) {
        //设置监听器
       mInterstitialAd.setTTAdInterstitialListener(interstitialListener);
       mInterstitialAd.showAd(this);
}

    public interface TTInterstitialAdListener{
    
    /**
     * 广告展示
     */
    void onInterstitialShow();
    
    /**
     * 广告被点击
     */
    void onInterstitialAdClick();

    /**
     * 关闭广告
     */
    void onInterstitialClosed();

    /**
     * 当广告打开浮层时调用，如打开内置浏览器、内容展示浮层，一般发生在点击之后
     * 常常在onAdLeftApplication之前调用，并非百分百回调，穿山甲SDK不支持
     */
    void onAdOpened();
    
    /**
     * 此方法会在用户点击打开其他应用（例如 Google Play）时
     * 于 onAdOpened() 之后调用，从而在后台运行当前应用。
     * 并非百分百回调，穿山甲SDK不支持
     */
    void onAdLeftApplication();
}

 
 
    /**
     * config回调
     */
    private TTAdsSdk.SettingConfigCallback mSettingConfigCallback = new TTAdsSdk.SettingConfigCallback() {
        @Override
        public void configLoad() {
            Log.e(TAG, "load ad 在config 回调中加载广告");
            loadAd(adUnitId, orientation);
        }
    };

    /**
     * 加载广告
     */
    private void laodAdWithCallback(final String adUnitId, final int orientation) {
        /**
         * 判断当前是否存在config 配置 ，如果存在直接加载广告 ，如果不存在则注册config加载回调
         */
        if (TTAdsSdk.configLoadSuccess()) {
            Log.e(TAG, "load ad 当前config配置存在，直接加载广告");
            loadAd(adUnitId, orientation);
        } else {
            Log.e(TAG, "load ad 当前config配置不存在，正在请求config配置....");
            TTAdsSdk.registerConfigCallback(mSettingConfigCallback); //不用使用内部类，否则在ondestory中无法移除该回调
        }
    }
    
    
 private void loadAd(final String adUnitId, int orientation) {
        mttRewardAd = new TTRewardAd(this, "901121543");
        //创建广告请求参数AdSlot,具体参数含义参考文档
        AdSlot adSlot = new AdSlot.Builder()
                .setSupportDeepLink(true)
                .setAdStyleType(AdSlot.TYPE_EXPRESS_AD)//AdSlot.TYPE_EXPRESS_AD 标识pangle使用动态模板激励视频;AdSlot.TYPE_NATIVE_AD:使用原生激励视频
                .setRewardName("金币") //奖励的名称
                .setRewardAmount(3)  //奖励的数量
                .setUserID("user123")//用户id,必传参数
                .setOrientation(orientation) //必填参数，期望视频的播放方向：TTAdConstant.HORIZONTAL 或 TTAdConstant.VERTICAL
                .build();
        
        //请求广告
        mttRewardAd.loadRewardAd(adSlot, new TTRewardedAdLoadCallback() {

            @Override
            public void onRewardVideoLoadFail(AdError adError) {
                loadSuccess = false;
            }

            @Override
            public void onRewardVideoAdLoad() {
                loadSuccess = true;
            }

            @Override
            public void onRewardVideoCached() {
                loadSuccess = true;//激励视频资源加载成功
            }
        });
    }
    
    @Override
    protected void onDestroy() {
        super.onDestroy();
        TTAdsSdk.unregisterConfigCallback(mSettingConfigCallback);
        if (mttRewardAd != null) {
            mttRewardAd.destroy();
        }
    }

 if (loadSuccess && mttRewardAd != null && mttRewardAd.isReady()) {
     //在获取到广告后展示,强烈建议在onRewardVideoCached回调后，展示广告，提升播放体验
     //该方法直接展示广告
     //展示广告，并传入广告展示的场景
     mttRewardAd.showRewardAd(RewardVideoActivity.this, mTTRewardedAdListener);
 }

public interface TTRewardedAdListener extends ITTAdatperCallback {
   
    /**
     * 广告的展示回调
     */
    void onRewardedAdShow();

    /**
     * 广告的下载bar点击回调-注意Admob的激励视频不会回调该方法
     */
    void onRewardClick();

    /**
     * 广告关闭的回调
     */
    void onRewardedAdClosed();

    /**
     * 视频播放完毕的回调 - Admob广告不存在该回调
     */
    void onVideoComplete();

    /**
     * 视频播放失败的回调 - Mintegral GDT Admob广告不存在该回调
     */
    void onVideoError();

    /**
     * 激励视频播放完毕，验证是否有效发放奖励的回调
     */
    void onRewardVerify(RewardItem rewardItem);
}

import hashlib

if __name__ == "__main__":
    trans_id = "6FEB23ACB0374985A2A52D282EDD5361u6643"
    app_security_key = "7ca31ab0a59d69a42dd8abc7cf2d8fbd"
    check_sign_raw = "%s:%s" % (app_security_key, trans_id)
    sign = hashlib.sha256(check_sign_raw).hexdigest()

    
     /**
     * config回调
     */
    private TTAdsSdk.SettingConfigCallback mSettingConfigCallback = new TTAdsSdk.SettingConfigCallback() {
        @Override
        public void configLoad() {
            Log.e(TAG, "load ad 在config 回调中加载广告");
            loadAd();
        }
    };

    /**
     * 加载广告
     */
    private void loadAdWithCallback() {
        /**
         * 判断当前是否存在config 配置 ，如果存在直接加载广告 ，如果不存在则注册config加载回调
         */
        if (TTAdsSdk.configLoadSuccess()) {
            Log.e(TAG, "load ad 当前config配置存在，直接加载广告");
            loadAd();
        } else {
            Log.e(TAG, "load ad 当前config配置不存在，正在请求config配置....");
            TTAdsSdk.registerConfigCallback(mSettingConfigCallback); //不能使用内部类，否则在ondestory中无法移除该回调
        }
    }
 
 private void loadAd(final String adUnitId, int orientation) {
    mTTFullVideoAd = new TTFullVideoAd(this, "901121073");
     //step4:创建广告请求参数AdSlot,具体参数含义参考文档
     AdSlot adSlot = new AdSlot.Builder()
             .setSupportDeepLink(true)
             .setAdStyleType(AdSlot.TYPE_EXPRESS_AD)//AdSlot.TYPE_EXPRESS_AD 标识pangle使用动态模板全屏视频;AdSlot.TYPE_NATIVE_AD:使用原生全屏视频
             .setRewardName("金币") //奖励的名称
             .setRewardAmount(3)  //奖励的数量
             .setUserID("user123")//用户id,必传参数
             .setMediaExtra("media_extra") //附加参数，可选
             .setOrientation(orientation) //必填参数，期望视频的播放方向：TTAdConstant.HORIZONTAL 或 TTAdConstant.VERTICAL
             .build();


     //请求广告
     mTTFullVideoAd.loadFullAd(adSlot, new TTFullVideoAdLoadCallback() {

         @Override
         public void onFullVideoLoadFail(AdError adError) {
             loadSuccess = false;
         }

         @Override
         public void onFullVideoAdLoad() {
             loadSuccess = true;
         }

         @Override
         public void onFullVideoCached() {
             loadSuccess = true;
         }
     });
 }
    @Override
    protected void onDestroy() {
        super.onDestroy();
        //注销config回调
        TTAdsSdk.unregisterConfigCallback(mSettingConfigCallback);
        if (mTTFullVideoAd != null) {
            mTTFullVideoAd.destroy();
        }
    }
 
 

if (loadSuccess && mTTFullVideoAd != null && mTTFullVideoAd.isReady()) {
        //在获取到广告后展示,强烈建议在onFullVideoCached回调后，展示广告，提升播放体验
       //该方法直接展示广告
       //展示广告，并传入广告展示的场景
       mTTFullVideoAd.showFullAd(FullVideoActivity.this, mTTFullVideoAdListener);
}

   public interface TTFullVideoAdListener extends ITTAdatperCallback {
    
    /**
     * 广告的展示回调
     */
    void onFullVideoAdShow();

    /**
     * 广告的下载bar点击回调
     */
    void onFullVideoAdClick();

    /**
     * 广告关闭的回调
     */
    void onFullVideoAdClosed();

    /**
     * 视频播放完毕的回调- Admob广告不存在该回调，
     */
    void onVideoComplete();

    /**
     * 视频播放失败的回调- Mintegral GDT Admob广告不存在该回调，仅穿山甲SDK广告回调
     */
    void onVideoError();

    /**
     * 跳过视频播放 - Mintegral GDT Admob广告不存在该回调，仅穿山甲SDK广告回调
     */
    void onSkippedVideo();
}

//设置dislike弹窗，如果有
if (ad.hasDislike()) {
    final TTAdDislike ttAdDislike = ad.getDislikeDialog((Activity) mContext);
    adViewHolder.mDislike.setVisibility(View.VISIBLE);
    adViewHolder.mDislike.setOnClickListener(new View.OnClickListener() {
        @Override
        public void onClick(View v) {
            //使用接口来展示
            ttAdDislike.showDislikeDialog();
            ttAdDislike.setDislikeCallback(new TTDislikeCallback() {
                @Override
                public void onSelected(int position, String value) {
                    TToast.show(mContext, "点击 " + value);
                    //用户选择不喜欢原因后，移除广告展示
                    mData.remove(ad);
                    sumCount--;//总数也要减少
                    notifyDataSetChanged();
                }

                @Override
                public void onCancel() {
                    TToast.show(mContext, "dislike 点击了取消");
                }
            });
        }
    });
} 

 //判断是否存在dislike按钮
if (ad.hasDislike()) {
    ad.setDislikeCallback((Activity) mContext, new TTDislikeCallback() {
        @Override
        public void onSelected(int position, String value) {
            TToast.show(mContext, "点击 " + value);
            //用户选择不喜欢原因后，移除广告展示
            mData.remove(ad);
            sumCount--;
            notifyDataSetChanged();
        }

        @Override
        public void onCancel() {
            TToast.show(mContext, "dislike 点击了取消");
        }
    });
}