Android 如何接入穿山甲广告？

目录

下载SDK
集成SDK

• AndroidManifest配置
• provider配置
• 运行环境配置
• 白名单配置

工具类

下载SDK

首先去穿山甲官网注册账号以及创建应用

点击进入平台 (我的是创建完账号并且登录之后是这个样子)

进来之后是如下界面

然后依次点击流量—>应用会进入到以下界面

然后点击创建应用根据提示走即可

创建完毕之后去依次点击流量–>代码位创建广告位 根据自己的需求去创建即可

最后点击接入选择SDK下载与文档选择Android平台SDK

下载完成之后开始集成

集成SDK

集成方式一

    导入aar及SDK依赖的jar包

将本SDK压缩包内的open_ad_sdk.aar复制到Application Module/libs文件夹(没有的话须手动创建), 并将以下代码添加到您app的build.gradle中：

dependencies {
    implementation(name: 'open_ad_sdk_4.4.0.2', ext: 'aar')
}

方式二：从穿山甲3.5.0.6版本开始，开发者也可以使用Gradle依赖导入穿山甲SDK

• 步骤一：添加仓库
  在project级别的build.gradle文件中添加Maven的引用，url ‘https://artifact.bytedance.com/repository/pangle’
  示例：

allprojects {
    repositories {
        maven {
          url 'https://artifact.bytedance.com/repository/pangle'
            }
      }
}

步骤二：添加依赖
在主module的build.gradle文件添加SDK依赖

dependencies {
     implementation 'com.pangle.cn:ads-sdk-pro:4.4.0.9'
}

Gradle版本要求：

自3400版本开始，穿山甲支持了Android R，引入了Android R的 标签,需要对gradle版本进行限制，限制范围为：3.3.3、 3.4.3、 3.5.4、3.6.4、4.0.1 ，开发者根据自身情况酌情升级

AndroidManifest配置

添加权限

注意: 穿山甲SDK不强制获取以上权限，即使没有获取可选权限SDK也能正常运行；获取以上权限将帮助穿山甲优化投放广告精准度和用户的交互体验，提高eCPM。

建议在广告请求前，合适的时机调用SDK提供的方法，在用户可以授权的情况下获取到声明中的权限，提高广告变现效率

//TTAdManager接口中的方法，context可以是Activity或Application
void requestPermissionIfNecessary(Context context);

provider配置

注意：
（1）为不影响下载类型广告使用 无论APP处于任何阶段provider都需要在清单文件中正常配置
（2）为不影响到广告的转化及收益 请务必在清单文件中配置xxx.TTMultiProvider
（3）${applicationId} 必须与开发者包名保持一致，否则会引发崩溃问题

适配Anroid7.0及以上如果您的应用需要在Anroid7.0及以上环境运行，请在AndroidManifest中添加如下代码：

在res/xml目录下，新建一个xml文件file_paths，在该文件中添加如下代码：

为了适配下载和安装相关功能，在工程中引用的包 com.android.support:support-v4:24.2.0使用24.2.0以及以上版本

注意：单进程或多进程都必须配置

运行环境配置

本SDK可运行于Android4.0 (API Level 14) 及以上版本。

如果开发者声明targetSdkVersion到API 23以上，请确保调用本SDK的任何接口前，已经申请到了SDK要求的所有权限，否则SDK部分特性可能受限

代码混淆

如果您需要使用proguard混淆代码，需确保不要混淆SDK的代码。 请在proguard.cfg文件(或其他混淆文件)尾部添加如下配置:35xx以及以下版本混淆规则如下：

-keep class com.bytedance.sdk.openadsdk.** { *; }
-keep public interface com.bytedance.sdk.openadsdk.downloadnew.** {*;}
-keep class com.pgl.sys.ces.* {*;}
-keep class com.bytedance.embed_dr.** {*;}
-keep class com.bytedance.embedapplog.** {*;}

36xx版本-38xx版本混淆规则如下：

-keep class com.bytedance.sdk.openadsdk.** { *; }
-keep public interface com.bytedance.sdk.openadsdk.downloadnew.** {*;}
-keep class ms.bd.c.**{*;}
-keep class com.bytedance.mobsec.**{*;} 
-keep class com.bytedance.embed_dr.** {*;}
-keep class com.bytedance.embedapplog.** {*;}
-keep interface com.bytedance.frameworks.baselib.network.http.cronet.I* {*;}
-keepnames class com.bytedance.framwork.core.sdkmonitor.SDKMonitorUtils

3900版本及以上版本混淆规则如下：

-keep class com.bytedance.sdk.openadsdk.** { *; }
-keep class com.bytedance.frameworks.** { *; }
 
-keep class ms.bd.c.Pgl.**{*;}
-keep class com.bytedance.mobsec.metasec.ml.**{*;}
 
-keep class com.ss.android.**{*;}
 
-keep class com.bytedance.embedapplog.** {*;}
-keep class com.bytedance.embed_dr.** {*;}
 
-keep class com.bykv.vk.** {*;}

4000版本混淆规则：以aar包里的混淆文件为准

注意: SDK代码被混淆后会导致广告无法展现或者其它异常

支持架构

注意: 3900以及以上版本SDK默认支持armeabi-v7a,arm64-v8a两种架构，如果有其他架构需求，请联系技术支持同学； 3900以下版本SDK中使用的so文件支持五种架构：x86,x86_64,armeabi,armeabi-v7a,arm64-v8a如果您应用中支持的架构超出这 五种，请在build.gradle中使用abiFilters选择支持的架构。如下所示：

ndk { // 设置支持的 SO 库构架，注意这里要根据你的实际情况来设置 
   abiFilters  armeabi-v7a ,  arm64-v8a , x86 , x86_64 ,  armeabi 
}

说明：
1、36xx-38xx版本中穿山甲增加了libmetasec_ml.so 库。
2、36xx-38xx版本若开发者使用armeabi架构，那么需要把armeabi-v7a下的 libmetasec_ml.so 拷贝到armeabi目录下使用。

白名单配置

注意：平台SDK包中whiteList.txt 白名单上的资源不支持混淆

配置完成之后创建一个SDK初始化脚本内容如下 初始化调用是在开屏界面调用 调用初始化成功之后会自动调用开屏代码

package com.unity3d.player.chuanshanjia;
 
import android.content.Context;
import android.util.Log;
 
import com.bytedance.sdk.openadsdk.TTAdConfig;
import com.bytedance.sdk.openadsdk.TTAdConstant;
import com.bytedance.sdk.openadsdk.TTAdManager;
import com.bytedance.sdk.openadsdk.TTAdSdk;
 
 
/**
 * 可以用一个单例来保存TTAdManager实例，在需要初始化sdk的时候调用
 */
public class TTAdManagerHolder {
 
    private static final String TAG = "TTAdManagerHolder";
 
    private static boolean sInit;
 
    private static String appid;
    private static String appName;
    private static  TTAdManagerHolder _Instance;
 
    public static TTAdManager get() {
        return TTAdSdk.getAdManager();
    }
 
    public static TTAdManagerHolder Inst(){
        if (_Instance == null){
            _Instance = new TTAdManagerHolder();
        }
        return _Instance;
    }
 
    public void init(final Context context,String aid,String aname) {
        appid = aid;
        appName = aname;
        Log.d(TAG, "TTAdManagerHolderinit aid:"+aid+" aname:"+aname);
        doInit(context);
    }
 
    //step1:接入网盟广告sdk的初始化操作，详情见接入文档和穿山甲平台说明
    private void doInit(Context context) {
        if (!sInit) {
            TTAdSdk.init(context, buildConfig(context), new TTAdSdk.InitCallback() {
                @Override
                public void success() {
                    Log.i(TAG, "success: " );
                    CsjSplashActivity.Inst().loadSplashAd();
                }
                @Override
                public void fail(int code, String msg) {
                    Log.i(TAG, "fail:  code = " + code + " msg = " + msg);
                }
            });
            sInit = true;
        }
    }
 
 
    private TTAdConfig buildConfig(Context context) {
        //强烈建议在应用对应的Application#onCreate()方法中调用，避免出现content为null的异常
        return new TTAdConfig.Builder()
        .appId(appid)
        .useTextureView(true) //默认使用SurfaceView播放视频广告,当有SurfaceView冲突的场景，可以使用TextureView
        .appName(appName)
        .titleBarTheme(TTAdConstant.TITLE_BAR_THEME_DARK)//落地页主题
        .allowShowNotify(true) //是否允许sdk展示通知栏提示,若设置为false则会导致通知栏不显示下载进度
        .debug(true) //测试阶段打开，可以通过日志排查问题，上线时去除该调用
        .directDownloadNetworkType(TTAdConstant.NETWORK_STATE_WIFI) //允许直接下载的网络状态集合,没有设置的网络下点击下载apk会有二次确认弹窗，弹窗中会披露应用信息
        .supportMultiProcess(false) //是否支持多进程，true支持
        .asyncInit(true) //是否异步初始化sdk,设置为true可以减少SDK初始化耗时。3450版本开始废弃~~
                //.httpStack(new MyOkStack3())//自定义网络库，demo中给出了okhttp3版本的样例，其余请自行开发或者咨询工作人员。
                .build();
    }
}

SDK集成完成之后开始接入SDK

工具类

ChuanShanJiaUtil

package com.unity3d.player.tools;
 
import android.app.Activity;
import android.content.Context;
import android.os.Build;
import android.text.TextUtils;
import android.util.DisplayMetrics;
import android.view.Display;
import android.view.DisplayCutout;
import android.view.View;
import android.view.ViewGroup;
import android.view.ViewParent;
import android.view.WindowInsets;
import android.view.WindowManager;
import android.widget.FrameLayout;
import android.widget.LinearLayout;
import android.widget.RelativeLayout;
 
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
 
public class ChuanShanJiaUtil {
    public static float getScreenWidthDp(Context context){
        final float scale = context.getResources().getDisplayMetrics().density;
        float width = context.getResources().getDisplayMetrics().widthPixels;
        return width / (scale <= 0 ? 1 : scale) + 0.5f;
    }
 
    //全面屏、刘海屏适配
    public static float getHeight(Activity activity) {
        hideBottomUIMenu(activity);
        float height;
        int realHeight = getRealHeight(activity);
        if (ChuanShanJiaUtil.hasNotchScreen(activity)) {
            height = px2dip(activity, realHeight - getStatusBarHeight(activity));
        }else {
            height = px2dip(activity, realHeight);
        }
        return height;
    }
 
    public static void hideBottomUIMenu(Activity activity) {
        if (activity == null) {
            return;
        }
        try {
            //隐藏虚拟按键，并且全屏
            if (Build.VERSION.SDK_INT > 11 && Build.VERSION.SDK_INT < 19) { // lower api
                View v = activity.getWindow().getDecorView();
                v.setSystemUiVisibility(View.GONE);
            } else if (Build.VERSION.SDK_INT >= 19) {
                //for new api versions.
                View decorView = activity.getWindow().getDecorView();
                int uiOptions = View.SYSTEM_UI_FLAG_LAYOUT_STABLE
                        | View.SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION
                        | View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN
                        | View.SYSTEM_UI_FLAG_HIDE_NAVIGATION // hide nav bar
                        //                    | View.SYSTEM_UI_FLAG_FULLSCREEN // hide status bar
                        | View.SYSTEM_UI_FLAG_IMMERSIVE;
                decorView.setSystemUiVisibility(uiOptions);
                activity.getWindow().addFlags(WindowManager.LayoutParams.FLAG_TRANSLUCENT_NAVIGATION);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
 
    //获取屏幕真实高度，不包含下方虚拟导航栏
    public static int getRealHeight(Context context) {
        WindowManager windowManager = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE);
        Display display = windowManager.getDefaultDisplay();
        DisplayMetrics dm = new DisplayMetrics();
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR1) {
            display.getRealMetrics(dm);
        } else {
            display.getMetrics(dm);
        }
        int realHeight = dm.heightPixels;
        return realHeight;
    }
 
    //获取状态栏高度
    public static float getStatusBarHeight(Context context) {
        float height = 0;
        int resourceId = context.getApplicationContext().getResources().getIdentifier("status_bar_height", "dimen", "android");
        if (resourceId > 0) {
            height = context.getApplicationContext().getResources().getDimensionPixelSize(resourceId);
        }
        return height;
    }
 
    public static int px2dip(Context context, float pxValue) {
        final float scale = context.getResources().getDisplayMetrics().density;
        return (int) (pxValue / (scale <= 0 ? 1 : scale) + 0.5f);
    }
 
    public static int dp2px(Context context, float dp) {
        final float scale = context.getResources().getDisplayMetrics().density;
        return (int) (dp * scale + 0.5f);
    }
 
    /**
     * 判断是否是刘海屏
     * @return
     */
    public static boolean hasNotchScreen(Activity activity){
        return isAndroidPHasNotch(activity)
                || getInt("ro.miui.notch", activity) == 1
                || hasNotchAtHuawei(activity)
                || hasNotchAtOPPO(activity)
                || hasNotchAtVivo(activity);
    }
 
    /**
     * Android P 刘海屏判断
     * @param activity
     * @return
     */
    public static boolean isAndroidPHasNotch(Activity activity){
        boolean result = false;
        if (android.os.Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
            DisplayCutout displayCutout = null;
            try {
                WindowInsets windowInsets = activity.getWindow().getDecorView().getRootWindowInsets();
                if (windowInsets != null) {
                    displayCutout = windowInsets.getDisplayCutout();
                }
                if (displayCutout != null) {
                    result = true;
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return result;
    }
 
    /**
     * 小米刘海屏判断.
     * @return 0 if it is not notch ; return 1 means notch
     * @throws IllegalArgumentException if the key exceeds 32 characters
     */
    public static int getInt(String key,Activity activity) {
        int result = 0;
        if (isMiui()){
            try {
                ClassLoader classLoader = activity.getClassLoader();
                @SuppressWarnings("rawtypes")
                Class SystemProperties = classLoader.loadClass("android.os.SystemProperties");
                //参数类型
                @SuppressWarnings("rawtypes")
                Class[] paramTypes = new Class[2];
                paramTypes[0] = String.class;
                paramTypes[1] = int.class;
                Method getInt = SystemProperties.getMethod("getInt", paramTypes);
                //参数
                Object[] params = new Object[2];
                params[0] = new String(key);
                params[1] = new Integer(0);
                result = (Integer) getInt.invoke(SystemProperties, params);
 
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            } catch (NoSuchMethodException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            } catch (IllegalArgumentException e) {
                e.printStackTrace();
            } catch (InvocationTargetException e) {
                e.printStackTrace();
            }
        }
        return result;
    }
 
    /**
     * 华为刘海屏判断
     * @return
     */
    public static boolean hasNotchAtHuawei(Context context) {
        boolean ret = false;
        try {
            ClassLoader classLoader = context.getClassLoader();
            Class HwNotchSizeUtil = classLoader.loadClass("com.huawei.android.util.HwNotchSizeUtil");
            Method get = HwNotchSizeUtil.getMethod("hasNotchInScreen");
            ret = (boolean) get.invoke(HwNotchSizeUtil);
        } catch (ClassNotFoundException e) {
        } catch (NoSuchMethodException e) {
        } catch (Exception e) {
        } finally {
            return ret;
        }
    }
 
    public static final int VIVO_NOTCH = 0x00000020;//是否有刘海
    public static final int VIVO_FILLET = 0x00000008;//是否有圆角
 
    /**
     * VIVO刘海屏判断
     * @return
     */
    public static boolean hasNotchAtVivo(Context context) {
        boolean ret = false;
        try {
            ClassLoader classLoader = context.getClassLoader();
            Class FtFeature = classLoader.loadClass("android.util.FtFeature");
            Method method = FtFeature.getMethod("isFeatureSupport", int.class);
            ret = (boolean) method.invoke(FtFeature, VIVO_NOTCH);
        } catch (ClassNotFoundException e) {
        } catch (NoSuchMethodException e) {
        } catch (Exception e) {
        } finally {
            return ret;
        }
    }
    /**
     * O-P-P-O刘海屏判断
     * @return
     */
    public static boolean hasNotchAtOPPO(Context context) {
        String temp = "com.kllk.feature.screen.heteromorphism";
        String name = getKllkDecryptString(temp);
        return context.getPackageManager().hasSystemFeature(name);
    }
 
    public static boolean isMiui() {
        boolean sIsMiui = false;
        try {
            Class clz = Class.forName("miui.os.Build");
            if (clz != null) {
                sIsMiui = true;
                //noinspection ConstantConditions
                return sIsMiui;
            }
        } catch (Exception e) {
            // ignore
        }
        return sIsMiui;
    }
 
    /**
     *用于o-p-p-o 版本隐私协议
     */
    public static String getKllkDecryptString(String encryptionString) {
 
        if (TextUtils.isEmpty(encryptionString)) {
            return "";
        }
        String decryptTag = "";
        String decryptCapitalized = "O" + "P" + "P" + "O";
        String decrypt = "o" + "p" + "p" + "o";
        if (encryptionString.contains("KLLK")) {
            decryptTag =  encryptionString.replace("KLLK", decryptCapitalized);
        } else if (encryptionString.contains("kllk")) {
            decryptTag = encryptionString.replace("kllk", decrypt);
        }
        return decryptTag;
 
    }
 
    public static void setViewSize(View view, int width, int height) {
        if (view.getParent() instanceof FrameLayout) {
            FrameLayout.LayoutParams lp = (FrameLayout.LayoutParams) view.getLayoutParams();
            lp.width = width;
            lp.height = height;
            view.setLayoutParams(lp);
            view.requestLayout();
        } else if (view.getParent() instanceof RelativeLayout) {
            RelativeLayout.LayoutParams lp = (RelativeLayout.LayoutParams) view.getLayoutParams();
            lp.width = width;
            lp.height = height;
            view.setLayoutParams(lp);
            view.requestLayout();
        } else if (view.getParent() instanceof LinearLayout) {
            LinearLayout.LayoutParams lp = (LinearLayout.LayoutParams) view.getLayoutParams();
            lp.width = width;
            lp.height = height;
            view.setLayoutParams(lp);
            view.requestLayout();
        }
    }
 
    public static int getScreenWidthInPx(Context context) {
        DisplayMetrics dm = context.getApplicationContext().getResources().getDisplayMetrics();
        return dm.widthPixels;
    }
 
    public static int getScreenHeightInPx(Context context) {
        DisplayMetrics dm = context.getApplicationContext().getResources().getDisplayMetrics();
        return dm.heightPixels;
    }
 
    public static int getScreenHeight(Context context) {
        return (int) (getScreenHeightInPx(context) + getStatusBarHeight(context));
    }
 
    public static void removeFromParent(View view) {
        if (view != null) {
            ViewParent vp = view.getParent();
            if (vp instanceof ViewGroup) {
                ((ViewGroup) vp).removeView(view);
            }
        }
    }
 
    /**
     * 获取全面屏宽高
     * @param context
     * @return
     */
    public static int[] getScreenSize(Context context) {
        int[] size = new int[]{0,0};
        if (context == null){
            return size;
        }
        WindowManager windowManager = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE);
        Display display = windowManager.getDefaultDisplay();
        DisplayMetrics dm = new DisplayMetrics();
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR1) {
            display.getRealMetrics(dm);
        } else {
            display.getMetrics(dm);
        }
        size[0] = dm.widthPixels;
        size[1] = dm.heightPixels;
        return size;
    }
}

ShowSeqUtils

package com.unity3d.player.tools;
 
import android.os.Environment;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.text.SimpleDateFormat;
import java.util.Date;
 
public class ShowSeqUtils {
    private FileReader fr;
    private BufferedReader br;
    private FileWriter fw;
    private BufferedWriter bw;
 
 
    public int loadShowSeq(){
        int show_seq = 1;
        //获取当前日期字符串
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        String data = sdf.format(new Date());
        //读取本地缓存show_seq的文件
        try {
            String rootPath =  Environment.getExternalStorageDirectory().getPath();
            File file = new File(rootPath + "/Android/data/com.snssdk.api/cache/adloadSeqTemp.txt");
            if (!file.exists()) {
                file.createNewFile();
                return show_seq;
            }
            fr = new FileReader(file);
            br = new BufferedReader(fr);
            String line = "";
            while ((line = br.readLine()) != null) {
                String[] temp = line.split(",");
                if (temp[0].equals(data)){
                    //日期相同返回字段
                    show_seq = Integer.parseInt(temp[1]);
                }
            }
            return show_seq;
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if(fr!=null){
                    fr.close();
                }
                if(br!=null){
                    br.close();
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return show_seq;
    }
 
    public void writeToFile(int show_seq){
        //获取当前日期字符串
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        String data = sdf.format(new Date());
        String content = data+","+show_seq;
        //读取本地缓存show_seq的文件
        try {
            String rootPath =  Environment.getExternalStorageDirectory().getPath();
            File file = new File(rootPath + "/Android/data/com.snssdk.api/cache/");
            if (!file.exists()) {
                file.mkdir();
            }
            String filename = file.getAbsolutePath()+"/adloadSeqTemp.txt";
            file = new File(filename);
            if(!file.exists()){
                file.createNewFile();
            }
            fw = new FileWriter(file, false);
            fw.write(content);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if(fw!=null){
                    fw.flush();
                    fw.close();
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}

TToast

package com.unity3d.player.tools;
 
import android.annotation.SuppressLint;
import android.content.Context;
import android.util.Log;
import android.widget.Toast;
 
public final class TToast {
    private static Toast sToast;
 
    public static void show(Context context, String msg) {
        show(context, msg, Toast.LENGTH_SHORT);
    }
 
    public static void show(Context context, String msg, int duration) {
        Toast toast = getToast(context);
        if (toast != null) {
            toast.setDuration(duration);
            toast.setText(String.valueOf(msg));
            toast.show();
        } else {
            Log.i("TToast", "toast msg: " + String.valueOf(msg));
        }
    }
 
    @SuppressLint("ShowToast")
    private static Toast getToast(Context context) {
        if (context == null) {
            return sToast;
        }
//        if (sToast == null) {
//            synchronized (TToast.class) {
//                if (sToast == null) {
        sToast = Toast.makeText(context.getApplicationContext(), "", Toast.LENGTH_SHORT);
//                }
//            }
//        }
        return sToast;
    }
 
    public static void reset() {
        sToast = null;
    }
}

＞作者：「Zyt吖」
原文链接：https://blog.csdn.net/qq_41973169/article/details/125427149

如有问题可扫描文末二维码一起讨论
同时可领取Android相关学习资料及面试题，大家一起进阶提升！！！