Android Mopub：与千年媒体原生ads适配器的集成

有人知道如何集成千年媒体原生广告适配器吗

我读了这一页：

下载了android适配器，然后用我的APID替换APID，但不知道DCN是什么，我在他们的网站上找不到它

我想我得到了以下错误，因为我没有输入DCN：

03-24 22:07:12.83229491-29491/？D/MoPub:正在尝试调用自定义 活动：com.mopub.nativeads.MillennialNative 03-24 22:07:12.850 29491-29491/? V/MoPub:本机Ad加载失败，错误为： CustomEventNative配置不正确。。03-24 22:07:13.328 29491-29491/? D/MoPub:正在尝试调用自定义事件： com.mopub.nativeads.MoPubCustomEventNative

这是他们的适配器我正在使用千年媒体：

package com.mopub.nativeads;

import android.app.Activity;
import android.content.Context;
import android.os.Handler;
import android.os.Looper;
import android.util.Log;
import android.view.View;

import com.millennialmedia.AppInfo;
import com.millennialmedia.MMException;
import com.millennialmedia.MMSDK;
import com.millennialmedia.NativeAd;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;

import static com.mopub.nativeads.NativeImageHelper.preCacheImages;

public class MillennialNative extends CustomEventNative {
    public static final String DCN_KEY = "dcn";
    public static final String APID_KEY = "XXX";
    private final static String LOGCAT_TAG = "MoPub->MM-Native";
    private static final Handler UI_THREAD_HANDLER = new Handler(Looper.getMainLooper());
    public String siteId;

    @Override
    protected void loadNativeAd(final Activity activity,
            final CustomEventNativeListener listener,
            final Map<String, Object> localExtras,
            final Map<String, String> serverExtras) {

        String placementId;

        if ( !MMSDK.isInitialized() ) {
            try {
                MMSDK.initialize(activity);
            } catch ( Exception e ) {
                Log.e(LOGCAT_TAG, "Unable to initialize the Millennial SDK-- " + e.getMessage());
                e.printStackTrace();
                UI_THREAD_HANDLER.post(new Runnable() {
                    @Override
                    public void run() {
                        listener.onNativeAdFailed(NativeErrorCode.NATIVE_ADAPTER_CONFIGURATION_ERROR);
                    }
                });
                return;
            }
        }

        if ( extrasAreValid( serverExtras )) {
            placementId = serverExtras.get(APID_KEY);
            siteId = serverExtras.get(DCN_KEY);
        } else {
            UI_THREAD_HANDLER.post(new Runnable() {
                @Override
                public void run() {
                    listener.onNativeAdFailed(NativeErrorCode.NATIVE_ADAPTER_CONFIGURATION_ERROR);
                }
            });
            return;
        }

        try {
            AppInfo ai = new AppInfo().setMediator("mopubsdk");
            if ( siteId != null && siteId.length() > 0 ) {
                ai = ai.setSiteId(siteId);
            } else {
                ai = ai.setSiteId(null);
            }

            MMSDK.setAppInfo(ai);
        } catch ( IllegalStateException e ) {
            Log.w(LOGCAT_TAG, "Caught exception: " + e.getMessage());
            UI_THREAD_HANDLER.post(new Runnable() {
                @Override
                public void run() {
                    listener.onNativeAdFailed(NativeErrorCode.NATIVE_ADAPTER_CONFIGURATION_ERROR);
                }
            });
            return;
        }

        try {
            NativeAd nativeAd = NativeAd.createInstance(placementId, NativeAd.NATIVE_TYPE_INLINE);
            final MillennialStaticNativeAd millennialStaticNativeAd =
                    new MillennialStaticNativeAd(activity,
                            nativeAd,
                            new ImpressionTracker(activity),
                            new NativeClickHandler(activity),
                            listener);
            millennialStaticNativeAd.loadAd();
        } catch ( MMException e ) {
            UI_THREAD_HANDLER.post(new Runnable() {
                @Override
                public void run() {
                    listener.onNativeAdFailed(NativeErrorCode.NATIVE_ADAPTER_CONFIGURATION_ERROR);
                }
            });
        }
    }

    private boolean extrasAreValid(final Map<String, String> serverExtras) {
        String placementId = serverExtras.get(APID_KEY);
        return (serverExtras.containsKey(APID_KEY) &&
                placementId != null && placementId.length() > 0 );
    }


    static class MillennialStaticNativeAd extends StaticNativeAd implements NativeAd.NativeListener {
        private final Context mContext;
        private NativeAd mNativeAd;
        private final ImpressionTracker mImpressionTracker;
        private final NativeClickHandler mNativeClickHandler;
        private final CustomEventNativeListener mListener;
        private final MillennialStaticNativeAd mMillennialStaticNativeAd;

        public MillennialStaticNativeAd(final Context context,
                final NativeAd nativeAd,
                final ImpressionTracker impressionTracker,
                final NativeClickHandler nativeClickHandler,
                final CustomEventNativeListener customEventNativeListener) {
            mContext = context.getApplicationContext();
            mNativeAd = nativeAd;
            mImpressionTracker = impressionTracker;
            mNativeClickHandler = nativeClickHandler;
            mListener = customEventNativeListener;
            mMillennialStaticNativeAd = this;

            nativeAd.setListener(this);
        }

        void loadAd() {
            Log.i(LOGCAT_TAG, "Loading native ad...");
            try {
                mNativeAd.load(mContext, null);
            } catch (MMException e) {
                Log.w(MillennialNative.LOGCAT_TAG, "Caught configuration error Exception.");
                e.printStackTrace();
                UI_THREAD_HANDLER.post(new Runnable() {
                    @Override
                    public void run() {
                        mListener.onNativeAdFailed(NativeErrorCode
                                .NATIVE_ADAPTER_CONFIGURATION_ERROR);
                    }
                });
            }
        }

        // Lifecycle Handlers
        @Override
        public void prepare(final View view) {
            // Must access these methods directly to get impressions to fire.
            mNativeAd.getIconImage();
            mNativeAd.getDisclaimer();
            mImpressionTracker.addView(view, this);
            mNativeClickHandler.setOnClickListener(view, this);
        }

        @Override
        public void clear(final View view) {
            mImpressionTracker.removeView(view);
            mNativeClickHandler.clearOnClickListener(view);
        }

        @Override
        public void destroy() {
            mImpressionTracker.destroy();
            mNativeAd.setListener(null);
            mNativeAd = null;
        }

        // Event Handlers
        @Override
        public void recordImpression(final View view) {
            notifyAdImpressed();
            try {
                mNativeAd.fireImpression();
                Log.i(LOGCAT_TAG, "Millennial native impression recorded.");
            } catch ( MMException m ) {
                Log.e(LOGCAT_TAG, "Millennial native impression NOT tracked: " + m.getMessage() );
            }
        }

        @Override
        public void handleClick(final View view) {
            notifyAdClicked();
            mNativeClickHandler.openClickDestinationUrl(getClickDestinationUrl(), view);
            mNativeAd.fireClicked();
            Log.i(LOGCAT_TAG, "Millennial native ad clicked!");
        }

        // MM'S Native mListener
        @Override
        public void onLoaded(NativeAd nativeAd) {
            // Set assets
            String iconImageUrl = nativeAd.getImageUrl(NativeAd.ComponentName.ICON_IMAGE, 1);
            String mainImageUrl = nativeAd.getImageUrl(NativeAd.ComponentName.MAIN_IMAGE, 1);

            setTitle(nativeAd.getTitle().getText().toString());
            setText(nativeAd.getBody().getText().toString());
            setCallToAction(nativeAd.getCallToActionButton().getText().toString());

            final String clickDestinationUrl = nativeAd.getCallToActionUrl();
            if (clickDestinationUrl == null) {
                UI_THREAD_HANDLER.post(new Runnable() {
                    @Override
                    public void run() {
                        Log.d(LOGCAT_TAG,
                                "Millennial native encountered null destination url. Failing over.");
                        mListener.onNativeAdFailed(
                                NativeErrorCode.NATIVE_ADAPTER_CONFIGURATION_ERROR);
                    }
                });
                return;
            }

            setClickDestinationUrl(clickDestinationUrl);
            setIconImageUrl(iconImageUrl);
            setMainImageUrl(mainImageUrl);

            final List<String> urls = new ArrayList<String>();
            if ( iconImageUrl != null ) { urls.add(iconImageUrl); }
            if ( mainImageUrl != null ) { urls.add(mainImageUrl); }

            UI_THREAD_HANDLER.post(new Runnable() {
                @Override
                public void run() {
                    // This has to be run on the main thread:
                    preCacheImages(mContext, urls, new NativeImageHelper.ImageListener() {
                        @Override
                        public void onImagesCached() {
                            mListener.onNativeAdLoaded(mMillennialStaticNativeAd);
                            Log.i(LOGCAT_TAG, "Millennial native ad loaded");
                        }

                        @Override
                        public void onImagesFailedToCache(NativeErrorCode errorCode) {
                            mListener.onNativeAdFailed(errorCode);
                        }
                    });

                }
            });
        }

        @Override
        public void onLoadFailed(NativeAd nativeAd, NativeAd.NativeErrorStatus nativeErrorStatus) {
            final NativeErrorCode error;
            switch ( nativeErrorStatus.getErrorCode() ) {
                case NativeAd.NativeErrorStatus.LOAD_TIMED_OUT:
                    error = NativeErrorCode.NETWORK_TIMEOUT;
                    break;
                case NativeAd.NativeErrorStatus.NO_NETWORK:
                    error = NativeErrorCode.CONNECTION_ERROR;
                    break;
                case NativeAd.NativeErrorStatus.UNKNOWN:
                    error = NativeErrorCode.UNSPECIFIED;
                    break;
                case NativeAd.NativeErrorStatus.LOAD_FAILED:
                case NativeAd.NativeErrorStatus.INIT_FAILED:
                    error = NativeErrorCode.UNEXPECTED_RESPONSE_CODE;
                    break;
                case NativeAd.NativeErrorStatus.ADAPTER_NOT_FOUND:
                    error = NativeErrorCode.NATIVE_ADAPTER_CONFIGURATION_ERROR;
                    break;
                case NativeAd.NativeErrorStatus.DISPLAY_FAILED:
                case NativeAd.NativeErrorStatus.EXPIRED:
                    error = NativeErrorCode.UNSPECIFIED;
                    break;
                default:
                    error = NativeErrorCode.NETWORK_NO_FILL;
            }
            UI_THREAD_HANDLER.post(new Runnable() {
                @Override
                public void run() {
                    mListener.onNativeAdFailed(error);
                }
            });
            Log.i(LOGCAT_TAG, "Millennial native ad failed: " + nativeErrorStatus.getDescription() );
        }

        @Override
        public void onClicked(NativeAd nativeAd, NativeAd.ComponentName componentName, int i) {
            Log.i(LOGCAT_TAG, "Millennial native SDK's click tracker fired.");
        }

        @Override
        public void onAdLeftApplication(NativeAd nativeAd) {
            Log.i(LOGCAT_TAG, "Millennial native SDK has left the application.");

        }

        @Override
        public void onExpired(NativeAd nativeAd) {
            Log.i(LOGCAT_TAG, "Millennial native ad has expired!");
        }

    }
}

package com.mopub.nativeads；
导入android.app.Activity；
导入android.content.Context；
导入android.os.Handler；
导入android.os.Looper；
导入android.util.Log；
导入android.view.view；
导入com.millennialmedia.AppInfo；
进口com.millennialmedia.mm除外；
进口com.millennialmedia.MMSDK；
进口com.millennialmedia.NativeAd；
导入java.util.ArrayList；
导入java.util.List；
导入java.util.Map；
导入静态com.mopub.nativeads.NativeImageHelper.preCacheImages；
公共类MillennialNative扩展了CustomEventNative{
公共静态最终字符串DCN_KEY=“DCN”；
公共静态最终字符串APID_KEY=“XXX”；
私有最终静态字符串LOGCAT_TAG=“MoPub->MM Native”；
私有静态最终处理程序UI_THREAD_Handler=新处理程序（Looper.getMainLooper（））；
公共字符串siteId；
@凌驾
受保护的void loadNativeAd（最终活动，
最终CustomEventNativeListener侦听器，
最终地图localExtras，
最终地图服务器（附加）{
字符串placementId；
如果（！MMSDK.isInitialized（））{
试一试{
初始化（活动）；
}捕获（例外e）{
Log.e（LOGCAT_标记，“无法初始化Millennial SDK--”+e.getMessage（））；
e、 printStackTrace（）；
UI\u THREAD\u HANDLER.post（新的Runnable（）{
@凌驾
公开募捐{
OnNativeAddFailed（NativeErrorCode.NATIVE_适配器_配置_错误）；
}
});
返回；
}
}
if（额外服务（服务器额外服务））{
placementId=serverExtras.get（APID_键）；
siteId=serverExtras.get（DCN_键）；
}否则{
UI\u THREAD\u HANDLER.post（新的Runnable（）{
@凌驾
公开募捐{
OnNativeAddFailed（NativeErrorCode.NATIVE_适配器_配置_错误）；
}
});
返回；
}
试一试{
AppInfo ai=new AppInfo（）.setMediator（“mopubsdk”）；
if（siteId！=null&&siteId.length（）>0）{
ai=ai.setSiteId（siteId）；
}否则{
ai=ai.setSiteId（空）；
}
MMSDK.setAppInfo（ai）；
}捕获（非法状态）{
w（LOGCAT_标记，“捕获异常：+e.getMessage（））；
UI\u THREAD\u HANDLER.post（新的Runnable（）{
@凌驾
公开募捐{
OnNativeAddFailed（NativeErrorCode.NATIVE_适配器_配置_错误）；
}
});
返回；
}
试一试{
NativeAd NativeAd=NativeAd.createInstance（placementId，NativeAd.NATIVE_TYPE_INLINE）；
最后一个千禧年统计数字与千禧年统计数字与千禧年统计数字=
新千禧年国家统计局（活动，
土生土长的，
新印象机（活动），
新的NativeClickHandler（活动），
听众）；
millennialStaticNativeAd.loadAd（）；
}捕获（MME例外）{
UI\u THREAD\u HANDLER.post（新的Runnable（）{
@凌驾
公开募捐{
OnNativeAddFailed（NativeErrorCode.NATIVE_适配器_配置_错误）；
}
});
}
}
专用布尔extrasAreValid（最终映射服务器Extras）{
String placementId=serverExtras.get（APID_键）；
返回（serverExtras.containsKey（APID_键）&&
placementId！=null&&placementId.length（）>0）；
}
静态类MillennialStaticNativeAd扩展了StaticNativeAd实现了NativeAd.NativeListener{
私有最终上下文mContext；
私有的本地和跨国公司；
私人最终印象机；
私有最终NativeClickHandler；
私人最终CustomEventNativeListener mListener；
私人最终千禧年统计数据和百万年统计数据；
公共MillennialStativeAD（最终上下文，
最终的NativeAd NativeAd，
最终印象机印象机印象机印象机，
最终的NativeClickHandler NativeClickHandler，
最终CustomEventNativeListener（自定义事件NativeListener）{
mContext=context.getApplicationContext（）；
mNativeAd=nativeAd；
mImpressionTracker=印象机；
mNativeClickHandler=nativeClickHandler；
mListener=customEventNativeListener；
mmillennialstativead=此；
nativeAd.setListener（this）；
}
void loadAd（）{
Log.i（LOGCAT_标签，“加载本地广告…”）；
试一试{
mNativeAd.load（mContext，null）；
}捕获（MME例外）{
Log.w（MillennialNative.LOGCAT_标记，“捕获的配置错误异常”）