Difference between revisions of "DCR Static iOS SDK"

From Engineering Client Portal

 
(3 intermediate revisions by the same user not shown)
Line 130: Line 130:
  
 
Sample code using AVPlayer.
 
Sample code using AVPlayer.
<code>ViewController.swift</code>
+
<code>LandingVC.swift</code>
  
 
<syntaxhighlight lang="swift">
 
<syntaxhighlight lang="swift">
 +
import UIKit
 +
import NielsenAppApi
 +
 +
 +
class LandingVC: UIViewController, NielsenAppApiDelegate {
 +
   
 +
    var nielsenMain : NielsenAppApi!
 +
    var sdkMethods : SDKMethods!
 +
    var data : [String : Any]!
 +
 
class ViewController: UIViewController, NielsenAppApiDelegate, AVPlayerViewControllerDelegate  {
 
class ViewController: UIViewController, NielsenAppApiDelegate, AVPlayerViewControllerDelegate  {
  
Line 139: Line 149:
 
   override func viewDidLoad() {
 
   override func viewDidLoad() {
 
         super.viewDidLoad()
 
         super.viewDidLoad()
 
 
         //Getting the instance of NielsenApi
 
         //Getting the instance of NielsenApi
 
         self.nielsenApi = NielsenInit.createNielsenApi(delegate: self)
 
         self.nielsenApi = NielsenInit.createNielsenApi(delegate: self)
 
 
             }
 
             }
 
   }
 
   }
 +
    override func viewDidAppear(_ animated: Bool) {     
 +
        self.data = sdkMethods.loadStaticMaster()    // This is just an example of populating the metadata
 +
        self.nielsenMain.loadMetadata(self.data)
 +
    }
 
</syntaxhighlight>
 
</syntaxhighlight>
 
|Objective C =  
 
|Objective C =  
Line 201: Line 213:
 
|Swift =  
 
|Swift =  
 
<syntaxhighlight lang="swift">
 
<syntaxhighlight lang="swift">
   
+
  class SDKMethods : NSObject{
let staticMetadata = [
+
    func loadStaticMaster() -> [String : Any] {     
 +
        //Loading Static Main data     
 +
        let staticData =
 +
            [
 
         "type": "static",
 
         "type": "static",
         "assetid": "C77664",
+
         "assetid": "C77664",     //optional for static measurement
 
         "section": "siteSection",
 
         "section": "siteSection",
 
         "segA": "segmentA",
 
         "segA": "segmentA",
 
         "segB": "CustomSegmentValueB", //optional
 
         "segB": "CustomSegmentValueB", //optional
 
         "segC": "CustomSegmentValueC", //optional
 
         "segC": "CustomSegmentValueC", //optional
];
+
        ]      
 +
        return staticData   
 +
    }
 
</syntaxhighlight>     
 
</syntaxhighlight>     
 
|Objective C =  
 
|Objective C =  
Line 215: Line 232:
 
NSDictionary * staticMetadata = @ {
 
NSDictionary * staticMetadata = @ {
 
     @ "type": @ "static",
 
     @ "type": @ "static",
         @ "assetid": @ "C77664",
+
         @ "assetid": @ "C77664", //optional for static measurement
 
         @ "section": @ "siteSection",
 
         @ "section": @ "siteSection",
 
         @ "segA": @ "Segment A",
 
         @ "segA": @ "Segment A",
Line 224: Line 241:
 
}}
 
}}
 
[[File:Sdk_dataflow.jpg|link=]]
 
[[File:Sdk_dataflow.jpg|link=]]
 +
 
=== Configure Metadata ===
 
=== Configure Metadata ===
 
Map the Nielsen keys to variables so that the content metadata is dynamically updated.
 
Map the Nielsen keys to variables so that the content metadata is dynamically updated.

Latest revision as of 21:32, 12 July 2019

Engineering Portal breadcrumbArrow.png Digital breadcrumbArrow.png DCR & DTVR breadcrumbArrow.png DCR Static iOS SDK

Overview

The Nielsen SDK is one of multiple framework SDKs that Nielsen provides to enable measuring linear (live) and on-demand TV viewing using TVs, mobile devices, etc. The App SDK is the framework for mobile application developers to integrate Nielsen Measurement into their media player applications. It supports a variety of Nielsen Measurement Products like Digital in TV Ratings, Digital Content Ratings (DCR & DTVR), and Digital Ad Ratings (DAR). Nielsen SDKs are also equipped to measure static content and can track key life cycle events of an application like:

  • Application launch events and how long app was running

Prerequisites for Static Measurement

This Guide is for the Implementation of Static Measurement. For implementation of Static and Video, please refer to the iOS DCR Video Implementation Guide.
To start using the App SDK, the following items are required:

Item Description Source
App ID (appid) Unique ID assigned to the player/site and configured by product. Contact Nielsen
sfcode Environment that the SDK must point to Contact Nielsen
Nielsen SDK Includes SDK frameworks and sample implementation; See iOS SDK Release Notes Download

If you do not have any of these pre-requisites or if you have any questions, please contact our SDK sales support team. Refer to Digital Measurement Onboarding guide for information on how to get a Nielsen App SDK and appid.

_ _

Implementation

This guide covers implementation steps for iOS using Xcode utilizing the Standard Nielsen SDK for DCR.

Setting up your Development Environment

Prior to SDK Version 6.2.0.0 the IOS framework has been distributed as a static library packaged into framework bundle format. Apple recommends to use dynamic framework, it has some benefits over static libraries like less executable file size of an app, faster startup time and native support in xCode IDE. Nielsen AppSDK has been transformed into dynamic framework in this release (static framework is still available).

If migrating from the static library to this new dynamic framework, once implemented, unless your specific application requires, you can remove the following Frameworks that were once required: [AdSupport, JavascriptCore, SystemConfiguration, Security, AVFoundation, libc++]

The Dynamic framework is created as a fat framework. It means that it contains slices required for devices (armv7, arm64) as well as slices required for simulators (i386, x86_64). Simulator slices are needed to let clients build and debug their app on the simulators, but they should be removed before sending the app to the AppStore. The example of the shell script that should be added as a Run Script phase in the application can be found here.

How to obtain the NielsenAppApi.Framework

The Nielsen AppSDK can either be downloaded directly or can be integrated directly within an application through the use of CocoaPods. We recommend using the CocoaPods-based integration whenever possible to ensure you maintain the most recent changes and enhancements to the Nielsen libraries.

Configuring Xcode Development Environment

Starting with SDK version 6.0.0.0, the Nielsen App SDK is compatible with Apple iOS versions 8.0 and above. In addition, when using the dynamic framework, all the required frameworks are linked automatically as the are needed. More details can be found here: https://stackoverflow.com/questions/24902787/dont-we-need-to-link-framework-to-xcode-project-anymore

Note: All communications between the SDK and the Census (Collection Facility) use HTTPS.

Download Framework

The first step is to download and copy the NielsenAppApi.framework bundle to the app project directory. (Not required if using CocaPods)

Add Framework

In the General tab for app configuration add NielsenAppApi.framework in the list of Embedded Binaries. (Not required if using CocaPods)

Add Path

Add path to the NielsenAppApi.framework in the Framework Search Paths build setting. (Not required if using CocaPods)

Import Framework

Add NielsenAppApi.framework module in the source file of your app:

Using Swift

Add the following:

import NielsenAppApi

Using Objective-C

@import NielsenAppApi;

SDK Initialization

The latest version of the Nielsen App SDK allows instantiating multiple instances of the SDK object, which can be used simultaneously without any issue. The sharedInstance API that creates a singleton object was deprecated prior to version 5.1.1. (Click here for an example of multiple instances)

The following table contains the list of arguments that can be passed via the AppInfo JSON schema.

  • The appid is provided by the Nielsen Technical Account Manager (TAM). The appid is a GUID data type and is specific to the application.
Parameter / Argument Description Source Required? Example
appid Unique id for the application assigned by Nielsen. It is GUID data type. Nielsen-specified Yes PXXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX
appname Name of the application Client-defined Optional; automatically detected in SDK 6.0.0.4 and above Nielsen Sample App
sfcode Nielsen collection facility to which the SDK should connect.

DTVR

  • "us"

DCR

  • "dcr"
Nielsen-specified Yes dcr
nol_devDebug Enables Nielsen console logging. Only required for testing Nielsen-specified Optional "DEBUG"

Debug flag for development environment

Player application developers / integrators can use Debug flag to check whether an App SDK API call made is successful. To activate the Debug flag, Pass the argument @"nol_devDebug":@"INFO", in the JSON string . The permitted values are:

  • INFO: Displays the API calls and the input data from the application (validate player name, app ID, etc.). It can be used as certification Aid.
  • WARN: Indicates potential integration / configuration errors or SDK issues.
  • ERROR: Indicates important integration errors or non-recoverable SDK issues.
  • DEBUG: Debug logs, used by the developers to debug more complex issues.

Once the flag is active, it logs each API call made and the data passed. The log created by this flag is minimal.

Note: DO NOT activate the Debug flag in a production environment.

Sample SDK Initialization Code

Swift

Swift 4.0 Example: NielsenInit.swift

import Foundation
import NielsenAppApi

class NielsenInit : NSObject {
    class func createNielsenApi(delegate: NielsenAppApiDelegate) -> NielsenAppApi?{
        
        let appInformation:[String: String] = [
            "appid": "PDA7D5EE6-B1B8-4123-9277-2A788XXXXXXX",
            "sfcode": "dcr",
            "nol_devDebug": "DEBUG"
        ]       
        return NielsenAppApi(appInfo:appInformation, delegate:delegate)
    }
}

Sample code using AVPlayer. LandingVC.swift

import UIKit
import NielsenAppApi


class LandingVC: UIViewController, NielsenAppApiDelegate {
    
    var nielsenMain : NielsenAppApi!
    var sdkMethods : SDKMethods!
    var data : [String : Any]!

class ViewController: UIViewController, NielsenAppApiDelegate, AVPlayerViewControllerDelegate  {

// your code//    

  override func viewDidLoad() {
        super.viewDidLoad()
        //Getting the instance of NielsenApi
        self.nielsenApi = NielsenInit.createNielsenApi(delegate: self)
            }
  }
    override func viewDidAppear(_ animated: Bool) {      
        self.data = sdkMethods.loadStaticMaster()     // This is just an example of populating the metadata
        self.nielsenMain.loadMetadata(self.data)
    }

Objective C

Initialize the Nielsen App object within the viewDidLoad view controller delegate method using initWithAppInfo:delegate:

If App SDK is initialized using init or new methods, it will ignore the API calls resulting in no measurement. The SDK will not return any errors.
    
#import "NielsenInit.h"
#import <NielsenAppApi/NielsenEventTracker.h>

@implementation NielsenInit

+ (NielsenAppApi *)createNielsenAppApiWithDelegate:(id<NielsenAppApiDelegate>)delegate
{    
    //Initialising the NielsenEventTracker class by passing app information which returns the instance of NielsenEventTracker.
    
    NSDictionary *appInformation = @{ @"appid": @"PDA7D5EE6-B1B8-4123-9277-2A788XXXXXXX",
                            @"appversion": @"1.0",
                            @"sfcode": @"dcr",
                            @"nol_devDebug": @"DEBUG", };
    
    return [[NielsenAppApi alloc] initWithAppInfo:appInformation delegate:delegate];
}

@end


The following would be the NielsenInit.h file:

#import <Foundation/Foundation.h>

@class NielsenAppApi;
@protocol NielsenAppApiDelegate;

@interface NielsenInit : NSObject

+ (NielsenAppApi *)createNielsenAppApiWithDelegate:(id<NielsenAppApiDelegate>)delegate;

@end

Sample Code:

@implementation ViewController

- (void)viewDidLoad {
    [super viewDidLoad];
        
    //Getting the instance of Nielsen SDK
    nielsenApi = [NielsenInit createNielsenAppApiWithDelegate:nil];


API Call sequence

Call loadMetadata with JSON metadata as below.

Swift

 class SDKMethods : NSObject{ 
    func loadStaticMaster() -> [String : Any] {      
        //Loading Static Main data      
        let staticData =
            [
        "type": "static",
        "assetid": "C77664",     //optional for static measurement
        "section": "siteSection",
        "segA": "segmentA",
        "segB": "CustomSegmentValueB", //optional
        "segC": "CustomSegmentValueC", //optional
        ]       
        return staticData    
    }

Objective C

 
NSDictionary * staticMetadata = @ {
    @ "type": @ "static",
        @ "assetid": @ "C77664",  //optional for static measurement
        @ "section": @ "siteSection",
        @ "segA": @ "Segment A",
        @ "segB": @ "CustomSegmentValueB", //optional
        @ "segC": @ "CustomSegmentValueC", //optional
}


Sdk dataflow.jpg

Configure Metadata

Map the Nielsen keys to variables so that the content metadata is dynamically updated.

The Nielsen reserved keys are:

Key Description Data Type Value Required?
type asset type fixed 'static' Yes
assetid Unique ID for each article dynamic custom
(no Special Characters)
No
section section of each site (e.g. section value should be first level in page URL: website.com/section). Limit to 25 unique values dynamic custom Yes
segA custom segment for reporting: Limit to 25 unique values across custom segments (segA + segB + segC) dynamic custom No
segB custom segment for reporting: Limit to 25 unique values across custom segments (segA + segB + segC) dynamic custom No
segC custom segment for reporting: Limit to 25 unique values across custom segments (segA + segB + segC) dynamic custom No

The values passed through the Nielsen keys will determine the breakouts that are seen in reporting. The custom segments (A, B & C) will roll into the sub-brand. To not use custom segments A, B and C, do not pass any value in these keys.

Aggregation Limits There are limits on the number of unique values that can be aggregated on in reporting. The specific limitations by key are:

Key Aggregation Limit
section maximum of 25 unique values (section <= 25)
segA Maximum number of unique values allowed across segA, segB, and segC is 25 (segA + segB + segC<= 25)
segB Maximum number of unique values allowed across segA, segB, and segC is 25 (segA + segB + segC<= 25)
segC Maximum number of unique values allowed across segA, segB, and segC is 25 (segA + segB + segC<= 25)

Handling Foreground and Background states

For iOS, background/foreground detection is handled by the app lifecylce APIs which are provided by Apple:

Foreground/Background state measurement is a requirement of Nielsen AppSDK implementation which is especially crucial for static measurement.

Privacy and Opt-Out

There are three primary methods for implementing user Opt-out preferences:

  1. OS-level Opt-out - managed by Limit Ad Tracking setting on device (preferred approach).
  2. Legacy Opt-out - Direct call to SDK; used only for older versions of Nielsen iOS SDK (< 5.1.1.18)
  3. App Level Opt-Out - Where Ad Framework cannot be leveraged

OS-level Opt-out

OS-level Opt-out method available on Nielsen iOS SDK Versions 5.1.1.18 and above.

The Nielsen SDK automatically leverages the iOS's Limit Ad Tracking setting. The user is opted out of demographic measurement if the OS-level "Limit Ad Tracking" setting is enabled. As a publisher, you cannot override this setting.

Legacy Opt-out

The Legacy opt-out method is only necessary for Nielsen iOS SDK versions less than 5.1.1.18.

Nielsen iOS SDK 5.1.1.17 and above will check for OS-level opt-out first, if available. The user will be opted out if indicated at the OS-level OR the App-level.

The legacy opt-out method works as follows:

  • Get the legacy Nielsen opt-out URL via optOutURL
  • Display a WebView element whose loadUrl is set to the value obtained from optOutURL
  • Detect if the WebView URL changes to a special URL that indicates Opt-in, or Opt-out and close the WebView
    • Opt-out if the WebView URL = nielsenappsdk://1
    • Opt-in if the WebView URL = nielsenappsdk://0
  • Pass the detected URL to the userOptOut function
    • Example:
      NielsenAppApi?.userOptOut("nielsenappsdk://1"); // User opt-out
      

Legacy Opt-out example code

Swift

var webView: WKWebView!
var NIELSEN_URL_OPT_OUT : String = "nielsenappsdk://1"
var NIELSEN_URL_OPT_IN : String = "nielsenappsdk://0"

func webView(_ webView: WKWebView, decidePolicyFor navigationAction: WKNavigationAction, decisionHandler: @escaping (WKNavigationActionPolicy) -> Void) {

       let urlStr = navigationAction.request.url?.absoluteString

        if(urlStr == NIELSEN_URL_OPT_OUT || urlStr == NIELSEN_URL_OPT_IN){
            let appApi = self.nielsenApi
            appApi?.userOptOut(urlStr)
            decisionHandler(.allow)

        }else{
           decisionHandler(.cancel)
        }
    }

Objective C

- (void)webView:(WKWebView *)webView decidePolicyForNavigationAction:(WKNavigationAction *)navigationAction decisionHandler:(void (^)(WKNavigationActionPolicy))decisionHandler {

    NSURLRequest *request = [navigationAction request];
    NSString *url = [[request URL]absoluteString];
    
    if([url isEqualToString:self.NIELSEN_URL_OPT_OUT] || [url isEqualToString:self.NIELSEN_URL_OPT_IN]){
        [self.nielsenApi userOptOut:url];
        decisionHandler(WKNavigationActionPolicyAllow);
    }else{
        decisionHandler(WKNavigationActionPolicyCancel);
    }        
}


Retrieve current Opt-Out preference

Whether the user is opted out via OS-level Opt-out or via App-level Opt-out, the current Opt-Out status as detected by the SDK is available via the optOutStatus property in the Nielsen SDK API

Required Privacy Links

Users must either have access to the "About Nielsen Measurement" page, or have similar text available within the native app. Include "About Nielsen Measurement" and "Your Choices" link in the Privacy Policy / EULA or as a button near the link to the app's Privacy Policy.

In addition, the following text must be included in your app store description.

"Please note: This app features Nielsen’s proprietary measurement software which contributes to market research, like Nielsen’s TV Ratings. Please see https://www.nielsen.com/digitalprivacy for more information"

Webview Example

The below code is an example of displaying the Nielsen Privacy page to the user.

Swift

import UIKit
import WebKit
import NielsenAppApi

class OptOutVC: UIViewController, NielsenAppApiDelegate, WKNavigationDelegate {
    
    var webView: WKWebView!
    var nielsenApi: NielsenAppApi!
    
    override func loadView() {
        webView = WKWebView()
        webView.navigationDelegate = self
        view = webView
    }
    
    override func viewDidLoad() {
        super.viewDidLoad()
        self.view.backgroundColor = UIColor(patternImage: UIImage(named: "new_ios_bg.png")!) 
        self.nielsenApi = NielsenInit.createNielsenApi(delegate: self)
        
        if let appApi = self.nielsenApi {
            //Getting the optPut URL from SDK
            if let url = URL(string: appApi.optOutURL) {
                webView.load(URLRequest(url: url))
                webView.allowsBackForwardNavigationGestures = true
            }
        }
    }
    
}

Objective C

- (void)viewDidLoad {

    [super viewDidLoad];
    
    //Setting background image
    UIImage *backgroundImage = [UIImage imageNamed:@"new_ios_bg.png"];
    UIImageView *backgroundImageView=[[UIImageView alloc]initWithFrame:self.view.frame];
    backgroundImageView.image=backgroundImage;
    [self.view insertSubview:backgroundImageView atIndex:0];

    self.nielsenApi = [NielsenInit createNielsenAppApiWithDelegate:nil];

    //Initialising the webview
    WKWebViewConfiguration *theConfiguration = [[WKWebViewConfiguration alloc] init];
    _wkwebView = [[WKWebView alloc] initWithFrame:self.view.frame configuration:theConfiguration];
    _wkwebView.navigationDelegate = self;

     //Getting the optPut URL from SDK
    NSURL *nsurl=[NSURL URLWithString:[self.nielsenApi optOutURL]];

    //Setting url request in webview
    NSURLRequest *nsrequest=[NSURLRequest requestWithURL:nsurl];

     //Setting url request in webview
    [_wkwebView loadRequest:nsrequest];

      //Adding webview to the controller view 
    [self.view addSubview:_wkwebView];   
}



App Level Opt Out

This is only used if the Ad Framework is not available. The Opt-Out occurs by opening a Nielsen-defined web page and passing the user choice from the 'WebView'. In order to do this, the application needs to:

  • Implement the UIWebView delegate method to open the Nielsen Privacy web page
  • Capture user's selection
  • Pass the selection back to the SDK via the userOptOut.

Capture and forward user selection

Swift

 func webView(webView: UIWebView, shouldStartLoadWithRequest request: NSURLRequest, navigationType: UIWebViewNavigationType) -> Bool {

        let command = request.url?.absoluteString
        if  command ==  "kNielsenWebClose"{

            self.perform(#selector(closeOptOutView), with: nil, afterDelay: 0)

            return false
        }    
        return NielsenAppApi.optOutURL
    }
  • The app gets the user selection string via webviews shouldStartLoadWithRequest and invokes userOptOut with user selection. The delegate method handles the 'WebView' URL requests, interprets the commands, and calls the SDK accordingly.
    • [nAppApiObject userOptOut:command] passes the user's selection on Nielsen Privacy page to the SDK to allow the SDK to perform the required functions.
Note: When 'WebView' is closed, pass the status returned from 'WebView' to the SDK within the app. The App SDK manages the user's choice (Opt-Out / Opt-In), the app does not need to manage this status.

Objective C

-(BOOL)webView:(UIWebView *)webView shouldStartLoadWithRequest:(NSURLRequest *)request navigationType:(UIWebViewNavigationType)navigationType
{
    NSString *command = [NSString stringWithFormat:@"%@",request.URL];
    if ([command isEqualToString:kNielsenWebClose]) {
        // Close the WebView
        [self performSelector:@selector(closeOptOutView) withObject:nil afterDelay:0];
        return NO;
    }
    // Retrieve next URL if it’s not opt-in/out selection
    return (![nAppApiObject userOptOut:command]);
}
  • The app gets the user selection string via webviews shouldStartLoadWithRequest and invokes userOptOut with user selection. The delegate method handles the 'WebView' URL requests, interprets the commands, and calls the SDK accordingly.
    • [nAppApiObject userOptOut:command] passes the user's selection on Nielsen Privacy page to the SDK to allow the SDK to perform the required functions.
Note: When 'WebView' is closed, pass the status returned from 'WebView' to the SDK within the app. The App SDK manages the user's choice (Opt-Out / Opt-In), the app does not need to manage this status.


Pre-Certification Checklists

After the application is ready to be sent for Nielsen Certification, please go through the Pre-Certification Checklist and ensure the app behaves as expected, before submitting to Nielsen.

Testing an Implementation - App

See Digital Measurement Testing.

Going Live

Following Nielsen testing, users need to make one update to the initialization call to ensure that the site is being measured properly.

  1. Debug Logging: Disable logging by deleting {nol_sdkDebug: 'DEBUG'} from initialization call.


Note: before going live you have to inform Nielsen team - this is necessary, because Nielsen team has to adjust internal configuration parameter to enable data collection. Without that notification no data will be collected and no data will be reported.