Come integrare il servizio Reach di Engagement in iOSHow to Integrate Engagement Reach on iOS

Prima di usare questa guida, è necessario eseguire la procedura di integrazione descritta nel documento relativo all'integrazione di Engagement in iOS .You must follow the integration procedure described in the How to Integrate Engagement on iOS document before following this guide.

Questa documentazione richiede XCode 8.This documentation requires XCode 8. Se si dipende davvero da XCode 7, è possibile usare iOS Engagement SDK v3.2.4.If you really depend on XCode 7 then you may use the iOS Engagement SDK v3.2.4. Esiste un bug noto nella versione precedente durante l'esecuzione su dispositivi iOS 10: le notifiche di sistema non vengono attivate.There is a known bug on this previous version while running on iOS 10 devices: system notifications are not actioned. Per risolvere il problema è necessario implementare l'API deprecata application:didReceiveRemoteNotification: nel delegato dell'app come segue:To fix this you will have to implement the deprecated API application:didReceiveRemoteNotification: in your app delegate as follows:

- (void)application:(UIApplication*)application
didReceiveRemoteNotification:(NSDictionary*)userInfo
{
    [[EngagementAgent shared] applicationDidReceiveRemoteNotification:userInfo fetchCompletionHandler:nil];
}

Importante

Questa soluzione non è consigliata dal momento che tale comportamento può cambiare in qualsiasi aggiornamento della versione iOS imminente (anche minore), poiché questa API iOS è deprecata.We do not recommend this workaround as this behavior can change in any upcoming (even minor) iOS version upgrade because this iOS API is deprecated. È opportuno passare a XCode 8 il prima possibile.You should switch to XCode 8 as soon as possible.

Abilitare l'app per la ricezione delle notifiche push SilentEnable your app to receive Silent Push Notifications

Importante

Per ricevere le notifiche push da Mobile Engagement, è necessario abilitare Silent Remote Notifications nell'applicazione.To receive Push Notifications from Mobile Engagement, you need to enable Silent Remote Notifications in your application. È necessario aggiungere il valore di notifica remota alla matrice UIBackgroundModes nel file Info.plist.You need to add the remote-notification value to the UIBackgroundModes array in your Info.plist file.

  1. Aprire il file info.plist del progetto.Open info.plist file in the project
  2. Fare clic con il pulsante destro del mouse sul primo elemento dell'elenco (Information Property List) e aggiungere una nuova riga.Right click on the top item in the list (Information Property List) and add a new row

  3. Nella nuova riga immettere Required background modesIn the new row enter Required background modes

  4. Fare clic sulla freccia sinistra per espandere la riga.Click on the left arrow to expand the row
  5. Aggiungere il seguente valore all'elemento 0 App downloads content in response to push notificationsAdd the following value to the item 0 App downloads content in response to push notifications

  6. Dopo avere apportato la modifica, info.plist XML deve contenere la chiave e il valore seguenti:Once you make the change, the info.plist XML should contain the following key and value:

     <key>UIBackgroundModes</key>
     <array>
     <string>remote-notification</string>
     </array>
    
  7. Se si usano Xcode 7+ e iOS 9+:If you are using Xcode 7+ and iOS 9+:

    • Abilitare Notifiche push in Destinazioni > Nome destinazione > Funzionalità.Enable Push Notifications in Targets > Your Target Name > Capabilities.

Procedura di integrazioneIntegration steps

Incorporare l'SDK del servizio Reach di Engagement nel progetto iOSEmbed the Engagement Reach SDK into your iOS project

  • Aggiungere l'SDK di Reach nel progetto Xcode.Add the Reach sdk in your Xcode project. In Xcode scegliere Project > Add to project e selezionare la cartella EngagementReach.In Xcode, go to Project > Add to project and choose the EngagementReach folder.

Modificare il delegato dell'applicazioneModify your Application Delegate

  • Nella parte superiore del file di implementazione, importare il modulo Reach di Engagement:At the top of your implementation file, import the Engagement Reach module:

    [...]
    #import "AEReachModule.h"
    
  • All'interno del metodo applicationDidFinishLaunching: o application:didFinishLaunchingWithOptions: creare un modulo Reach e passarlo alla riga di inizializzazione di Engagement esistente:Inside method applicationDidFinishLaunching: or application:didFinishLaunchingWithOptions:, create a reach module and pass it to your existing Engagement initialization line:

    - (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions {
      AEReachModule* reach = [AEReachModule moduleWithNotificationIcon:[UIImage imageNamed:@"icon.png"]];
      [EngagementAgent init:@"Endpoint={YOUR_APP_COLLECTION.DOMAIN};SdkKey={YOUR_SDK_KEY};AppId={YOUR_APPID}" modules:reach, nil];
      [...]
    
      return YES;
    }
    
  • Nella stringa "icon.png" inserire il nome dell'immagine da usare come icona di notifica.Modify 'icon.png' string with the image name you want as your notification icon.
  • Se si vuole impostare l'opzione Update badge value nelle campagne di copertura oppure usare le campagne di push nativo </SaaS/Reach API/Campaign format/Native Push>, è necessario consentire al modulo di copertura di gestire autonomamente l'icona della notifica. In questo modo, il modulo cancella automaticamente la notifica dell'applicazione e ripristina il valore memorizzato da Engagement, ogni volta che l'applicazione viene avviata o eseguita in primo piano.If you want to use the option Update badge value in Reach campaigns or if you want to use native push </SaaS/Reach API/Campaign format/Native Push> campaigns, you must let the Reach module manage the badge icon itself (it will automatically clear the application badge and also reset the value stored by Engagement every time the application is started or foregrounded). È possibile effettuare questa operazione aggiungendo la riga seguente dopo il modulo di inizializzazione Reach:This is done by adding the following line after Reach module initialization:

    [reach setAutoBadgeEnabled:YES];
    
  • Se si vuole gestire il push dei dati Reach, è necessario consentire al delegato dell'applicazione di uniformarsi al protocollo AEReachDataPushDelegate.If you want to handle Reach data push, you must let your Application delegate conform to the AEReachDataPushDelegate protocol. Aggiungere la riga seguente dopo l'inizializzazione del modulo Reach:Add the following line after Reach module initialization:

    [reach setDataPushDelegate:self];
    
  • A questo punto, è possibile implementare i metodi onDataPushStringReceived: e onDataPushBase64ReceivedWithDecodedBody:andEncodedBody: nel delegato dell'applicazione:Then you can implement the methods onDataPushStringReceived: and onDataPushBase64ReceivedWithDecodedBody:andEncodedBody: in your application delegate:

    -(BOOL)didReceiveStringDataPushWithCategory:(NSString*)category body:(NSString*)body
    {
       NSLog(@"String data push message with category <%@> received: %@", category, body);
       return YES;
    }
    
    -(BOOL)didReceiveBase64DataPushWithCategory:(NSString*)category decodedBody:(NSData *)decodedBody encodedBody:(NSString *)encodedBody
    {
       NSLog(@"Base64 data push message with category <%@> received: %@", category, encodedBody);
       // Do something useful with decodedBody like updating an image view
       return YES;
    }
    

CategoriaCategory

Il parametro category è facoltativo quando si crea una campagna per il push dei dati e consente di filtrare i push dei dati.The category parameter is optional when you create a Data Push campaign and allows you to filter data pushes. Questo parametro è utile quando si vuole effettuare il push di vari tipi di dati Base64 al fine di identificare il tipo prima dell'analisi.This is useful if you want to push different kinds of Base64 data and want to identify their type before parsing them.

L'applicazione è ora pronta per ricevere e visualizzare i contenuti Reach.Your application is now ready to receive and display reach contents!

Come ricevere annunci e sondaggi in qualsiasi momentoHow to receive announcements and polls at any time

Engagement consente di inviare notifiche Reach agli utenti finali, in qualsiasi momento, usando Apple Push Notification Service.Engagement can send Reach notifications to your end users at any time by using the Apple Push Notification Service.

Per attivare questa funzionalità, è necessario preparare l'applicazione all'uso delle notifiche push Apple e modificare il delegato dell'applicazione.To enable this functionality, you'll have to prepare your application for Apple push notifications and modify your application delegate.

Preparare l'applicazione per le notifiche push ApplePrepare your application for Apple push notifications

Seguire la procedura in: How to Prepare your Application for Apple Push NotificationsPlease follow the guide : How to Prepare your Application for Apple Push Notifications

Aggiungere il codice del client adeguatoAdd the necessary client code

A questo punto, l'applicazione dovrebbe avere un certificato push registrato di Apple nel front-end di Engagement.At this point your application should have a registered Apple push certificate in the Engagement frontend.

Nel caso in cui non sia stato già fatto, è necessario registrare l'applicazione affinché possa ricevere notifiche push.If it's not done already, you need to register your application to receive push notifications.

  • Importare il framework User Notification :Import the User Notification framework:

      #import <UserNotifications/UserNotifications.h>
    
  • Aggiungere la riga seguente all'avvio dell'applicazione (in genere, in application:didFinishLaunchingWithOptions:):Add the following line when your application starts (typically in application:didFinishLaunchingWithOptions:):

      if (NSFoundationVersionNumber >= NSFoundationVersionNumber_iOS_8_0)
      {
          if (NSFoundationVersionNumber > NSFoundationVersionNumber_iOS_9_x_Max)
          {
              [UNUserNotificationCenter.currentNotificationCenter requestAuthorizationWithOptions:(UNAuthorizationOptionBadge | UNAuthorizationOptionSound | UNAuthorizationOptionAlert) completionHandler:^(BOOL granted, NSError * _Nullable error) {}];
          }else
          {
              [application registerUserNotificationSettings:[UIUserNotificationSettings settingsForTypes:(UIUserNotificationTypeBadge | UIUserNotificationTypeSound | UIUserNotificationTypeAlert)   categories:nil]];
          }
          [application registerForRemoteNotifications];
      }
      else
      {
          [application registerForRemoteNotificationTypes:(UIRemoteNotificationTypeBadge | UIRemoteNotificationTypeSound | UIRemoteNotificationTypeAlert)];
      }
    

In seguito, è necessario fornire a Engagement il token del dispositivo restituito dai server Apple.Then, You need to provide to Engagement the device token returned by Apple servers. Questa operazione viene effettuata nel delegato dell'applicazione, all'interno del metodo application:didRegisterForRemoteNotificationsWithDeviceToken: :This is done in the method named application:didRegisterForRemoteNotificationsWithDeviceToken: in your application delegate:

- (void)application:(UIApplication*)application didRegisterForRemoteNotificationsWithDeviceToken:(NSData*)deviceToken
{
    [[EngagementAgent shared] registerDeviceToken:deviceToken];
}

Infine, è necessario comunicare all'SDK di Engagement il momento in cui l'applicazione riceve una notifica remota.Finally, you have to inform the Engagement SDK when your application receives a remote notification. A tale scopo, chiamare il metodo applicationDidReceiveRemoteNotification:fetchCompletionHandler: nel delegato dell'applicazione:To do that, call the method applicationDidReceiveRemoteNotification:fetchCompletionHandler: in your application delegate:

- (void)application:(UIApplication*)application didReceiveRemoteNotification:(NSDictionary*)userInfo fetchCompletionHandler:(void (^)(UIBackgroundFetchResult result))handler
{
    [[EngagementAgent shared] applicationDidReceiveRemoteNotification:userInfo fetchCompletionHandler:handler];
}

Importante

Per impostazione predefinita, Reach di Engagement controlla completionHandler.By default, Engagement Reach controls the completionHandler. Se si desidera rispondere manualmente al blocco handler nel codice, è possibile passare nil per l'argomento handler e controllare il completamento del blocco.If you want to manually respond to the handler block in your code, you can pass nil for the handler argument and control the completion block yourself. Vedere il tipo UIBackgroundFetchResult per un elenco di valori possibili.See the UIBackgroundFetchResult type for a list of possible values.

Esempio completoFull example

Di seguito, è riportato un esempio completo sull'integrazione:Here is a full example of integration:

#pragma mark -
#pragma mark Application lifecycle

- (BOOL)application:(UIApplication*)application didFinishLaunchingWithOptions:(NSDictionary*)launchOptions
{
  /* Reach module */
  AEReachModule* reach = [AEReachModule moduleWithNotificationIcon:[UIImage imageNamed:@"icon.png"]];
  [reach setAutoBadgeEnabled:YES];

  /* Engagement initialization */
  [EngagementAgent init:@"Endpoint={YOUR_APP_COLLECTION.DOMAIN};SdkKey={YOUR_SDK_KEY};AppId={YOUR_APPID}" modules:reach, nil];
  [[EngagementAgent shared] setPushDelegate:self];

  /* Views */
  [window addSubview:[tabBarController view]];
  [window makeKeyAndVisible];

  [application registerForRemoteNotificationTypes:UIRemoteNotificationTypeAlert|UIRemoteNotificationTypeBadge|UIRemoteNotificationTypeSound];
  return YES;
}

- (void)application:(UIApplication*)application didRegisterForRemoteNotificationsWithDeviceToken:(NSData*)deviceToken
{
  [[EngagementAgent shared] registerDeviceToken:deviceToken];
}

- (void)application:(UIApplication *)application didReceiveRemoteNotification:(NSDictionary *)userInfo fetchCompletionHandler:(void (^)(UIBackgroundFetchResult result))handler
{
    [[EngagementAgent shared] applicationDidReceiveRemoteNotification:userInfo fetchCompletionHandler:handler];
}

Risolvere i conflitti del delegato UNUserNotificationCenterResolve UNUserNotificationCenter delegate conflicts

Se né l'applicazione né una delle librerie di terze parti implementa il valore UNUserNotificationCenterDelegate, è possibile ignorare questa parte.If neither your application or one of your third party libraries implements a UNUserNotificationCenterDelegate then you can skip this part.

Un delegato UNUserNotificationCenter viene usato dall'SDK per monitorare il ciclo di vita delle notifiche di Engagement sui dispositivi che eseguono iOS 10 o versioni successive.A UNUserNotificationCenter delegate is used by the SDK to monitor the life cycle of Engagement notifications on devices running on iOS 10 or greater. L'SDK include un'implementazione specifica del protocollo UNUserNotificationCenterDelegate, ma può essere presente solo un delegato UNUserNotificationCenter per ogni applicazione.The SDK has its own implementation of the UNUserNotificationCenterDelegate protocol but there can be only one UNUserNotificationCenter delegate per application. Qualsiasi altro delegato aggiunto all'oggetto UNUserNotificationCenter sarà in conflitto con l'oggetto Engagement.Any other delegate added to the UNUserNotificationCenter object will conflict with the Engagement one. Se l'SDK rileva il delegato dell'utente o di terze parti, non userà l'implementazione specifica per consentire di risolvere i conflitti.If the SDK detects your or any other third party's delegate then it will not use its own implementation to give you a chance to resolve the conflicts. Sarà necessario aggiungere la logica di Engagement al delegato per risolvere i conflitti.You will have to add the Engagement logic to your own delegate in order to resolve the conflicts.

A questo scopo è possibile procedere in due modi:There are two ways to achieve this.

Proposta 1: inoltrare semplicemente le chiamate del delegato all'SDK:Proposal 1, simply by forwarding your delegate calls to the SDK:

#import <UIKit/UIKit.h>
#import "EngagementAgent.h"
#import <UserNotifications/UserNotifications.h>


@interface MyAppDelegate : NSObject <UIApplicationDelegate, UNUserNotificationCenterDelegate>
@end

@implementation MyAppDelegate

- (void)userNotificationCenter:(UNUserNotificationCenter *)center willPresentNotification:(UNNotification *)notification withCompletionHandler:(void (^)(UNNotificationPresentationOptions options))completionHandler
{
  // Your own logic.

  [[EngagementAgent shared] userNotificationCenterWillPresentNotification:notification withCompletionHandler:completionHandler]
}

- (void)userNotificationCenter:(UNUserNotificationCenter *)center didReceiveNotificationResponse:(UNNotificationResponse *)response withCompletionHandler:(void(^)())completionHandler
{
  // Your own logic.

  [[EngagementAgent shared] userNotificationCenterDidReceiveNotificationResponse:response withCompletionHandler:completionHandler]
}
@end

Proposta 2: ereditare dalla classe AEUserNotificationHandlerOr proposal 2, by inheriting from the AEUserNotificationHandler class

#import "AEUserNotificationHandler.h"
#import "EngagementAgent.h"

@interface CustomUserNotificationHandler :AEUserNotificationHandler
@end

@implementation CustomUserNotificationHandler

- (void)userNotificationCenter:(UNUserNotificationCenter *)center willPresentNotification:(UNNotification *)notification withCompletionHandler:(void (^)(UNNotificationPresentationOptions options))completionHandler
{
  // Your own logic.

  [super userNotificationCenter:center willPresentNotification:notification withCompletionHandler:completionHandler];
}

- (void)userNotificationCenter:(UNUserNotificationCenter *)center didReceiveNotificationResponse: UNNotificationResponse *)response withCompletionHandler:(void(^)())completionHandler
{
  // Your own logic.

  [super userNotificationCenter:center didReceiveNotificationResponse:response withCompletionHandler:completionHandler];
}

@end

Nota

È possibile determinare se una notifica proviene o meno da Engagement passando il suo dizionario userInfo al metodo della classe dell'agente isEngagementPushPayload:.You can determine whether a notification comes from Engagement or not by passing its userInfo dictionary to the Agent isEngagementPushPayload: class method.

Assicurarsi che il delegato dell'oggetto UNUserNotificationCenter sia impostato sul delegato nel metodo application:willFinishLaunchingWithOptions: o nel metodo application:didFinishLaunchingWithOptions: del delegato dell'applicazione.Make sure that the UNUserNotificationCenter object's delegate is set to your delegate within either the application:willFinishLaunchingWithOptions: or the application:didFinishLaunchingWithOptions: method of your application delegate. Se ad esempio è stata implementata la Proposta 1 precedente:For instance, if you implemented the above proposal 1:

  - (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions {
    // Any other code

    [UNUserNotificationCenter currentNotificationCenter].delegate = self;
    return YES;
  }

Come personalizzare le campagneHow to customize campaigns

NotificheNotifications

Esistono due tipi di notifiche: quelle di sistema e quelle in-app.There are two types of notifications: system and in-app notifications.

Le notifiche di sistema vengono gestite da iOS e non possono essere personalizzate.System notifications are handled by iOS, and cannot be customized.

Le notifiche in-app sono costituite da una visualizzazione che viene aggiunta in modo dinamico alla finestra corrente dell'applicazione.In-app notifications are made of a view that is dynamically added to the current application window. Si tratta di una sovrimpressione di notifica.This is called a notification overlay. Le sovrimpressioni delle notifiche sono ideali per un'integrazione rapida, poiché non richiedono alcuna modifica delle visualizzazioni dell'applicazione.Notification overlays are great for a fast integration because they does not require you to modify any view in your application.

LayoutLayout

Per modificare l'aspetto delle notifiche in-app, è possibile personalizzare il file AENotificationView.xib , purché vengano conservati i valori dei tag e i tipi delle visualizzazioni secondarie esistenti.To modify the look of your in-app notifications, you can simply modify the file AENotificationView.xib to your needs, as long as you keep the tag values and types of the existing subviews.

Per impostazione predefinita, le notifiche in-app vengono visualizzate nella parte inferiore dello schermo.By default, in-app notifications are presented at the bottom of the screen. Se si preferisce visualizzarle nella parte superiore dello schermo, modificare il file AENotificationView.xib fornito e la proprietà AutoSizing della visualizzazione principale in modo che venga mantenuta nella parte superiore della visualizzazione sovrapposta.If you prefer to display them at the top of screen, edit the provided AENotificationView.xib and change the AutoSizing property of the main view so it can be kept at the top of its superview.

CategorieCategories

La modifica del layout fornito comporta un cambiamento nell'aspetto di tutte le notifiche.When you modify the provided layout, you modify the look of all your notifications. Le categorie consentono di definire diversi aspetti assegnati (comportamenti) delle notifiche.Categories allow you to define various targeted looks (possibly behaviors) for notifications. Quando si crea una campagna Reach, è possibile specificare una categoria.A category can be specified when you create a Reach campaign. Tenere presente che le categorie consentono di personalizzare annunci e sondaggi, come descritto successivamente nel documento.Keep in mind that categories also let you customize announcements and polls, that is described later in this document.

Per registrare un gestore di categoria per le notifiche, è necessario aggiungere una chiamata una volta inizializzato il modulo di portata.To register a category handler for your notifications, you need to add a call once the reach module is initialized.

AEReachModule* reach = [AEReachModule moduleWithNotificationIcon:[UIImage imageNamed:@"icon.png"]];
[reach registerNotifier:myNotifier forCategory:@"my_category"];
...

myNotifier deve essere un'istanza di un oggetto conforme al protocollo AENotifier.myNotifier must be an instance of an object that conforms to the protocol AENotifier.

È possibile implementare i metodi del protocollo autonomamente o scegliere di implementare di nuovo la classe AEDefaultNotifier esistente, che esegue già la maggior parte delle operazioni.You can implement the protocol methods by yourself or you can choose to reimplement the existing class AEDefaultNotifier which already performs most of the work.

Ad esempio, se si desidera ridefinire la visualizzazione delle notifiche per una categoria specifica, è possibile attenersi a questo esempio:For example, if you want to redefine the notification view for a specific category, you can follow this example:

#import "AEDefaultNotifier.h"
#import "AENotificationView.h"
@interface MyNotifier : AEDefaultNotifier
@end

@implementation MyNotifier

-(NSString*)nibNameForCategory:(NSString*)category
{
  return "MyNotificationView";
}

@end

In questo semplice esempio di categoria si presuppone che nel pacchetto dell'applicazione sia presente un file denominato MyNotificationView.xib .This simple example of category assume that you have a file named MyNotificationView.xib in your main application bundle. Se il metodo non è in grado di trovare un file .xibcorrispondente, la notifica non viene visualizzata ed Engagement restituisce un messaggio nella console.If the method is not able to find a corresponding .xib, the notification will not be displayed and Engagement will output a message in the console.

Il file con estensione nib fornito deve rispettare le regole seguenti:The provided nib file should respect the following rules:

  • Deve includere soltanto una visualizzazione.It should only contain one view.
  • Le visualizzazioni secondarie devono essere di un tipo analogo a quelle presenti all'interno del file nib AENotificationView.xibSubviews should be of the same types as the ones inside the provided nib file named AENotificationView.xib
  • Le visualizzazioni secondarie devono disporre degli stessi tag di quelle presenti nel file nib AENotificationView.xib.Subviews should have the same tags as the ones inside the provided nib file named AENotificationView.xib

Suggerimento

È sufficiente copiare il file nib fornito, denominato AENotificationView.xib, e apportare modifiche a tale file.Just copy the provided nib file, named AENotificationView.xib, and start working from there. Fare però attenzione, poiché la visualizzazione all'interno del file nib è associata alla classe AENotificationView.But be careful, the view inside this nib file is associated to the class AENotificationView. Questa classe ha ridefinito il metodo layoutSubViews in modo da spostare e ridimensionare le visualizzazioni secondarie in base al contesto.This class redefined the method layoutSubViews to move and resize its subviews according to context. È possibile sostituirla con una classe UIView o con una classe di visualizzazione personalizzata.You may want to replace it with an UIView or you custom view class.

Se si desidera personalizzare ulteriormente le notifiche (ad esempio, caricare la visualizzazione direttamente dal codice), si consiglia di fare riferimento al codice di origine fornito e alla documentazione relativa alle classi di Protocol ReferencesDefaultNotifier e AENotifier.If you need deeper customization of your notifications(if you want for instance to load your view directly from the code), it is recommended to take a look at the provided source code and class documentation of Protocol ReferencesDefaultNotifier and AENotifier.

Tenere presente che è possibile usare la stessa notifica per più categorie.Note that you can use the same notifier for multiple categories.

Inoltre, è possibile ridefinire il componente di notifica predefinito nel modo seguente:You can also redefined the default notifier like this:

AEReachModule* reach = [AEReachModule moduleWithNotificationIcon:[UIImage imageNamed:@"icon.png"]];
[reach registerNotifier:myNotifier forCategory:kAEReachDefaultCategory];
Gestione delle notificheNotification handling

Quando si usa la categoria predefinita, alcuni metodi del ciclo di vita vengono chiamati sull'oggetto AEReachContent per segnalare le statistiche e aggiornare lo stato della campagna:When using the default category, some life cycle methods are called on the AEReachContent object to report statistics and update the campaign state:

  • Quando la notifica viene visualizzata in un'applicazione, il metodo displayNotification (per la segnalazione delle statistiche) viene chiamato da AEReachModule se handleNotification: restituisce YES.When the notification is displayed in application, the displayNotification method is called (which reports statistics) by AEReachModule if handleNotification: returns YES.
  • Se la notifica viene ignorata, viene chiamato il metodo exitNotification, vengono segnalate le statistiche e le campagne successive possono essere elaborate.If the notification is dismissed, the exitNotification method is called, statistic is reported and next campaigns can now be processed.
  • Se la notifica viene selezionata, viene chiamato actionNotification , vengono segnalate le statistiche e viene eseguita l'azione associata.If the notification is clicked, actionNotification is called, statistic is reported and the associated action is performed.

Se l'implementazione di AENotifier ignora il comportamento predefinito, è necessario chiamare i metodi del ciclo di vita autonomamente.If your implementation of AENotifier bypasses the default behavior, you have to call these life cycle methods by yourself. Negli esempi seguenti vengono descritte alcune situazioni nelle quali viene ignorato il comportamento predefinito:The following examples illustrate some cases where the default behavior is bypassed:

  • Il metodo AEDefaultNotifier non è stato esteso, ad esempio la gestione delle categorie è stata implementata da zero.You don't extend AEDefaultNotifier, e.g. you implemented category handling from scratch.
  • È stato eseguito l'override di prepareNotificationView:forContent:. Assicurarsi di mappare almeno onNotificationActioned o onNotificationExited a uno dei controlli dell'interfaccia utente.You overrode prepareNotificationView:forContent:, be sure to map at least onNotificationActioned or onNotificationExited to one of your U.I controls.

Avviso

Se handleNotification: genera un'eccezione, i contenuti vengono eliminati e viene chiamato il metodo drop. L'evento viene segnalato nelle modifiche ed è possibile procedere con l'elaborazione delle campagne successive.If handleNotification: throws an exception, the content is deleted and drop is called, this is reported in statistics and next campaigns can now be processed.

Includere la notifica come parte di una visualizzazione esistenteInclude notification as part of an existing view

Le sovrimpressioni rappresentano un metodo ottimale per eseguire integrazioni rapide; talvolta, però, non sono convenienti e possono produrre effetti collaterali indesiderati.Overlays are great for a fast integration but can be sometimes not convenient, or can have unwanted side effects.

Se il sistema di sovrimpressione di alcune visualizzazioni non è soddisfacente, è possibile personalizzarlo.If you're not satisfied with the overlay system in some of your views, you can customize it for these views.

È possibile decidere di includere un layout per le notifiche personalizzato nelle visualizzazioni esistenti.You can decide to include our notification layout in your existing views. A tale scopo, sono disponibili due stili di implementazione:To do so, there is two implementation styles:

  1. Aggiungere la visualizzazione delle notifiche usando lo strumento di creazione delle interfacceAdd the notification view using interface builder

    • Aprire lo strumento di creazione delle interfacceOpen Interface Builder
    • Posizionare un oggetto UIView della dimensione di 320x60 (768x60 su iPad) nell'area in cui si vuole visualizzare la notificaPlace a 320x60 (or 768x60 if you are on iPad) UIView where you want the notification to appear
    • Impostare il tag della visualizzazione sul valore seguente: 36822491Set the Tag value for this view to : 36822491
  2. Aggiungere la visualizzazione delle notifiche a livello di programmazione.Add the notification view programmatically. È sufficiente aggiungere il codice seguente, quando viene inizializzata la visualizzazione:Just add the following code when your view has been initialized:

    UIView* notificationView = [[UIView alloc] initWithFrame:CGRectMake(0, 0, 320, 60)]; //Replace x and y coordinate values to your needs.
    notificationView.tag = NOTIFICATION_AREA_VIEW_TAG;
    [self.view addSubview:notificationView];
    

La macro NOTIFICATION_AREA_VIEW_TAG è disponibile in AEDefaultNotifier.h.NOTIFICATION_AREA_VIEW_TAG macro can be found in AEDefaultNotifier.h.

Nota

Il componente di notifica predefinito rileva automaticamente che il layout per le notifiche è incluso nella visualizzazione e non vi aggiunge una sovrimpressione.The default notifier automatically detects that the notification layout is included in this view and will not add an overlay for it.

Annunci e sondaggiAnnouncements and polls

LayoutLayouts

È possibile modificare i file AEDefaultAnnouncementView.xib e AEDefaultPollView.xib, purché vengano mantenuti i valori dei tag e i tipi di visualizzazioni secondarie esistenti.You can modify the files AEDefaultAnnouncementView.xib and AEDefaultPollView.xib as long as you keep the tag values and types of the existing subviews.

CategorieCategories

Layout alternativiAlternate layouts

In modo analogo alle notifiche, è possibile impostare la categoria di una campagna in modo che disponga di layout alternativi per gli annunci e i sondaggi.Like notifications, the campaign's category can be used to have alternate layouts for your announcements and polls.

Per creare la categoria di un annuncio, è necessario estendere AEAnnouncementViewController e registrarlo quando viene inizializzato il modulo Reach:To create a category for an announcement, you must extend AEAnnouncementViewController and register it once the reach module has been initialized:

AEReachModule* reach = [AEReachModule moduleWithNotificationIcon:[UIImage imageNamed:@"icon.png"]];
[reach registerAnnouncementController:[MyCustomAnnouncementViewController class] forCategory:@"my_category"];

Nota

Ogni volta che un utente selezionerà la notifica di un annuncio con categoria "my_category", il controller di visualizzazione registrato (in questo caso MyCustomAnnouncementViewController) verrà inizializzato chiamando il metodo initWithAnnouncement:. In questo modo, la visualizzazione verrà aggiunta alla finestra corrente dell'applicazione.Each time a user will click on a notification for an announcement with the category "my_category", your registered view controller (in that case MyCustomAnnouncementViewController) will be initialized by calling the method initWithAnnouncement: and the view will be added to the current application window.

Durante l'implementazione della classe AEAnnouncementViewController, è necessario leggere la proprietà announcement al fine di inizializzare le visualizzazioni secondarie.In your implementation of the AEAnnouncementViewController class you will have to read the property announcement to initialize your subviews. Fare riferimento all'esempio seguente, nel quale due etichette vengono inizializzate mediante le proprietà title e body della classe AEReachAnnouncement:Consider the example below, where two labels are initialized using title and body properties of the AEReachAnnouncement class:

-(void)loadView
{
    [super loadView];

    UILabel* titleLabel = [[UILabel alloc] initWithFrame:CGRectMake(10, 20, 300, 60)];
    titleLabel.font = [UIFont systemFontOfSize:32.0];
    titleLabel.text = self.announcement.title;

    UILabel* bodyLabel = [[UILabel alloc] initWithFrame:CGRectMake(10, 20, 300, 60)];
    bodyLabel.font = [UIFont systemFontOfSize:24.0];
    bodyLabel.text = self.announcement.body;

    [self.view addSubview:titleLabel];
    [self.view addSubview:bodyLabel];
}

Se non si vuole caricare le visualizzazioni autonomamente, ma solo riutilizzare il layout predefinito della visualizzazione di annunci, è sufficiente impostare il controller di visualizzazione personalizzato in modo che estenda la classe AEDefaultAnnouncementViewController fornita.If you don't want to load your views by yourself but you just want to reuse the default announcement view layout, you can simply make your custom view controller extends the provided class AEDefaultAnnouncementViewController. In tal caso, duplicare il file nib AEDefaultAnnouncementView.xib e rinominarlo in modo che possa essere caricato dal controller di visualizzazione personalizzato. Nel caso di un controller denominato CustomAnnouncementViewController, assegnare il nome CustomAnnouncementView.xib al file nib.In that case, duplicate the nib file AEDefaultAnnouncementView.xib and rename it so it can be loaded by your custom view controller (for a controller named CustomAnnouncementViewController, you should call your nib file CustomAnnouncementView.xib).

Per sostituire la categoria predefinita degli annunci, è sufficiente registrare il controller di visualizzazione personalizzato per la categoria definita in kAEReachDefaultCategory:To replace the default category of announcements, simply register your custom view controller for the category defined in kAEReachDefaultCategory:

[reach registerAnnouncementController:[MyCustomAnnouncementViewController class] forCategory:kAEReachDefaultCategory];

È possibile personalizzare i sondaggi nello stesso modo:Polls can be customized the same way :

AEReachModule* reach = [AEReachModule moduleWithNotificationIcon:[UIImage imageNamed:@"icon.png"]];
[reach registerPollController:[MyCustomPollViewController class] forCategory:@"my_category"];

Questa volta, l'oggetto MyCustomPollViewController fornito deve estendere AEPollViewController.This time, the provided MyCustomPollViewController must extend AEPollViewController. In alternativa, è possibile scegliere di eseguire l'estensione dal controller predefinito: AEDefaultPollViewController.Or you can choose to extend from the default controller: AEDefaultPollViewController.

Importante

Ricordare di chiamare il metodo action (submitAnswers: per i controller di visualizzazione sondaggi personalizzati) o il metodo exit prima di ignorare il controller di visualizzazione.Don't forget to call either action (submitAnswers: for custom poll view controllers) or exit method before the view controller is dismissed. In caso contrario, le statistiche non verranno inviate (vale a dire, nessuna analisi sulla campagna) e le successive campagne non verranno notificate fino al riavvio del processo dell'applicazione.Otherwise, statistics won't be sent (i.e. no analytics on the campaign) and more importantly next campaigns will not be notified until the application process is restarted.

Esempio di implementazioneImplementation example

In questa implementazione la visualizzazione di annuncio personalizzata viene caricata da un file xib esterno.In this implementation the custom announcement view is loaded from an external xib file.

Come per la personalizzazione avanzata delle notifiche, si consiglia di esaminare il codice sorgente dell'implementazione standard.Like for advanced notification customization, it is recommended to look at the source code of the standard implementation.

CustomAnnouncementViewController.h

//Interface
@interface CustomAnnouncementViewController : AEAnnouncementViewController {
  UILabel* titleLabel;
  UITextView* descTextView;
  UIWebView* htmlWebView;
  UIButton* okButton;
  UIButton* cancelButton;
}

@property (nonatomic, retain) IBOutlet UILabel* titleLabel;
@property (nonatomic, retain) IBOutlet UITextView* descTextView;
@property (nonatomic, retain) IBOutlet UIWebView* htmlWebView;
@property (nonatomic, retain) IBOutlet UIButton* okButton;
@property (nonatomic, retain) IBOutlet UIButton* cancelButton;

-(IBAction)okButtonClicked:(id)sender;
-(IBAction)cancelButtonClicked:(id)sender;

CustomAnnouncementViewController.m

//Implementation
@implementation CustomAnnouncementViewController
@synthesize titleLabel;
@synthesize descTextView;
@synthesize htmlWebView;
@synthesize okButton;
@synthesize cancelButton;

-(id)initWithAnnouncement:(AEReachAnnouncement*)anAnnouncement
{
  self = [super initWithNibName:@"CustomAnnouncementViewController" bundle:nil];
  if (self != nil) {
    self.announcement = anAnnouncement;
  }
  return self;
}

- (void) dealloc
{
  [titleLabel release];
  [descTextView release];
  [htmlWebView release];
  [okButton release];
  [cancelButton release];
  [super dealloc];
}

- (void)viewDidLoad {
  [super viewDidLoad];

  /* Init announcement title */
  titleLabel.text = self.announcement.title;

  /* Init announcement body */
  if(self.announcement.type == AEAnnouncementTypeHtml)
  {
    titleLabel.hidden = YES;
    htmlWebView.hidden = NO;
    [htmlWebView loadHTMLString:self.announcement.body baseURL:[NSURL URLWithString:@"http://localhost/"]];
  }
  else
  {
    titleLabel.hidden = NO;
    htmlWebView.hidden = YES;
    descTextView.text = self.announcement.body;
  }

  /* Set action button label */
  if([self.announcement.actionLabel length] > 0)
    [okButton setTitle:self.announcement.actionLabel forState:UIControlStateNormal];

  /* Set exit button label */
  if([self.announcement.exitLabel length] > 0)
    [cancelButton setTitle:self.announcement.exitLabel forState:UIControlStateNormal];
}

#pragma mark Actions

-(IBAction)okButtonClicked:(id)sender
{
    [self action];
}

-(IBAction)cancelButtonClicked:(id)sender
{
    [self exit];
}

@end