In questo nuovo tutorial faremo un re-make del #T016 dove avevamo già trattato l’argomento di come implementare le Push Notification nelle nostre applicazioni iPhone e iPad. Questa nuova guida è aggiornata su Xcode 4.3.2 e usa le librerie PHP EasyAPNS.
Ringraziamo lo sviluppatore Gabriele Merlonghi, creatore delle applicazioni, GPS Alarm Pro e AskToMe! (che potete trovare su App Store seguendo i link diretti) il quale ha scritto per noi questa utilissima guida.
Come funzionano le notifiche push?
Ci sono 3 componenti essenziali su cui dovrete lavorare per far funzionare le notifiche push nella vostra applicazione iPhone:
- I profili e certificati dell’applicazione, che hanno abilitata la funzione Push Notification
- Un back-end su un vostro Web Server on line con PHP e MySQL
- Alcuni metodi dedicati alle Push Notification all’interno dell’AppDelegate.m dell’applicazione
Il meccanismo delle notifiche push si basa sull’infrastruttura dell’Apple Push Notification Service che, nel corso del tutorial, chiameremo per comodità APNs. Esso consiste in un server di Apple denominato Push Notification Server (PNS) che fa da dispatcher di tutti i messaggi di notifica inviati a tutti i dispositivi iOS.
L’APNs consente al dispositivo iOS dell’utente di restare continuamente connesso con il PNS utilizzando una connessione TCP/IP.
Una volta che il meccanismo è funzionante, quando desideriamo inviare una notifica push alla nostra applicazione installata sul dispositivo dell’utente, dobbiamo contattare il servizio APNs di Apple affinché consegni il messaggio alla precisa applicazione installata sul dispositivo desiderato.
Per rendere funzionante il dialogo con l’Apple Push Notification service (APNs), il nostro compito è di scrivere un’applicazione su un nostro server che faccia da provider delle notifiche push e che comunichi proprio con tale server Apple. La nostra applicazione provider invierà il messaggio al server APNs, che a sua volta recapiterà il messaggio, attraverso la connessione TCP/IP, a tutti i dispositivi che hanno la nostra applicazione installata e che hanno dato il consenso alla ricezione delle notifiche.
Facendo riferimento alla figura sopra in modo molto sintetico i principali passaggi che dovranno verificarsi sono:
- Sul terminale iOS dell’utente, quando verrà lanciata l’app verrà chiesto all’utente che questa intende inviargli delle notifiche. L’utente può quindi accettare o rifiutare. Per andare avanti occorre ovviamente che accetti.
- Dopo l’accettazione dell’utente di cui al punto 1, c’è uno scambio di messaggi tra iOS e l’APNs, che decretano la creazione del token. Questo viene inviato (insieme ad altre info del device) al database gestito con EasyAPNs sul vostro server. In questo modo il dispositivo iOS viene censito dal vostro server.
- Con le modalità e gli scopi che voi deciderete coerentemente con la vostra particolare App, il server si preoccuperà di inviare al PNS una richiesta di messaggio di notifica verso uno o più devices che sono censiti nel database di EasyAPNs.
- Il PNS si preoccuperà fisicamente di consegnare la notifica sul o sui terminali iOS di destinazione.
Step 1: Creazione dei Certificati e Profili
Accedere all’iPhone Developer Program Portal ed andare nella sezione App IDs. Non è possibile utilizzare un profilo con wild-card (ovvero con l’asterisco) per cui, se non avete già un profilo senza wild-card, dovete crearne uno nuovo cliccando su “New App ID”. Il consiglio generale è quello di usare un App ID distinto per ciascun’applicazione.
Dopo aver creato l’App ID, cliccate su Configure e create il certificato SSL seguendo la procedura guidata (molto semplice). Al termine del procedimento, scaricate il certificato appena creato (file con estensione .cer).
Ora dovete installare il certificato appena scaricato: doppio click su di esso e il certificato sarà importato nel Portachiavi. Nel Portachiavi, andate nella categoria “I miei certificati” e noterete un certificato chiamato “Apple Development Push Services”. Cliccateci sopra col tasto destro del mouse e cliccate quindi su Esporta. Salvate il file con il nome apns-dev-cert.p12. Tornate al certificato “Apple Development Push Services” ed espandetelo cliccando sulla freccia grigia alla sua sinistra. Noterete una chiave, cliccateci sopra col tasto destro del mouse ed esportatela salvandola col nome apns-dev-key.p12.
Aprite il terminale e posizionatevi nella cartella dove avete esportato i file sopra citati. Date i seguenti comandi, uno dopo l’altro (inserendo la password e la passphrase dove richiesto):
openssl pkcs12 -clcerts -nokeys -out apns-dev-cert.pem -in apns-dev-cert.p12 openssl pkcs12 -nocerts -out apns-dev-key.pem -in apns-dev-key.p12 openssl rsa -in apns-dev-key.pem -out apns-dev-key-noenc.pem cat apns-dev-cert.pem apns-dev-key-noenc.pem > apns-dev.pem
Tra tutti i file generati, a voi interessa il file apns-dev.pem, che dovrete caricare sul vostro server APNs (non preoccupatevi, lo vedremo nello step successivo). L’installazione dei certificati è terminata.
Ora dovete installare i profili. Tornate quindi nell’iPhone Developer Program Portal e andate nella sezione Provisioning. Create un nuovo profilo oppure (se esisteva già prima) rigeneratelo per avere la funzione di Push Notification abilitata.
Per caricarlo su Xcode, con la versione 4.3.2, è sufficiente andare nell’Organizer, poi sulla sezione Devices, quindi in Library -> Provisioning Profiles ed infine cliccare sull’icona sull’angolo in basso a destra di Refresh. Vi verranno chieste le credenziali di accesso dell’Apple ID di sviluppo che possedete ed automaticamente Xcode si sincronizzerà con tutti profili definiti sul portale Apple.
Tutta questa procedura di creazione di certificati e profili va eseguita due volte: una per il development (per sviluppare e testate l’applicazione iOS) e l’altra per la distribution.
Step 2: Preparazione del Server con EasyAPNs
Per utilizzare le Notifiche Push nella vostra applicazione, dovete disporre di un vostro server remoto sempre accessibile, nel quale memorizzare il token dei vari dispositivi degli utenti e che si preoccuperà di comunicare con il PNS di Apple per inviare i messaggi che vorrete.
La scelta dell’Hosting
Nelle mie prove ho utilizzato un Ubuntu Server domestico, ovviamente con Apache, PHP e MySQL installati, ma in produzione, ovviamente, occorre andare con un hosting apposito che dia delle garanzie di affidabilità.
Ci sono tantissime soluzioni di hosting di tutti i tipi e per tutte le tasche, ma c’è un requisito molto importante che occorre tenere in considerazione da subito nella scelta dell’hosting per un APNs, ovvero: che supporti SSL. Questa caratteristica è richiesta dalla tipologia di connessione che occorre stabilire tra il server APNs e il PNS di Apple, che ovviamente è imposta da Apple stessa per garantire ad utenti e sviluppatori il corretto grado di sicurezza per un servizio di questo genere.
Ho fatto un piccolo scouting di hosting gratuiti attraverso il motore di ricerca FreeHosting, a questo link trovate i risultati filtrati con il supporto a PHP, MySQL e SSL.
Fate molta attenzione a quest’aspetto, perché su moltissimi servizi di hosting anche commerciali il supporto SSL non è affatto scontato, anzi in base alle mie ricerche è una caratteristica rara.
Nel momento in cui questo tutorial è stato scritto, sembrerebbe che FreeHostingNoAds sia una possibile soluzione gratuita per ospitare un servizio APNs. Considerate che questa segnalazione non vuole avere uno scopo di soluzione assoluta, ciascun sviluppatore dovrebbe ricercare il corretto servizio di hosting in base alle proprie esigenze. Se possedete già un dominio, prima di tutto fate una verifica se avete già i requisiti necessari per APNs (che vi ricordo, sono il supporto a PHP, MySQL e SSL), in questo modo potrete utilizzare l’infrastruttura di hosting, che magari già pagate senza dover fare nuove spese.
La scelta di EasyAPNs e la sua personalizzazione
A differenza di altre soluzioni open source EasyAPNs risalta per due punti che ritengo importanti:
- E’ ben documentata e quindi facilmente personalizzabile.
- Integra già una soluzione di database per i dispositivi che si registrano alle notifiche.
Una volta terminati gli steps previsti da questo tutorial, l’unica cosa che rimane a carico dello sviluppatore è quella di preoccuparsi di come triggerare il messaggio di notifica e su quali dispositivi (se a tutti o su alcuni in particolare) che ovviamente dipende moltissimo dalla natura dell’applicazione iOS specifica.
EasyAPNs può essere scaricato direttamente dal repository su GitHub.
Nel momento in cui questo tutorial è stato scritto, sono state trovate delle differenze tra i sorgenti online e la documentazione presente sul portale web http://www.easyapns.com anche per questo motivo è nato questo tutorial. Mi riferisco in particolare alla parte di codice Objective-C che vedremo sullo step successivo.
Ora concentriamoci sulla messa in opera del server ovvero sulla creazione del database de sulla parametrizzazione dei sorgenti in PHP.
Nelle sezioni seguenti, si dà per scontato sul server siano operativi i seguenti servizi:
- Apache2
- PHP
- MySQL
- SSL
Nel caso questi pre-requisiti non fossero operativi si rimanda alla verifica di questi con il servizio di hosting oppure alla messa a punto di un LAMP server (una semplice guida qui) nel caso di un server di cui si ha la completa gestione (come potrebbe essere quello domestico).
Nelle sezioni seguenti si fa riferimento all’esperienza su un Ubuntu Server domestico 12.04, ma valgono le stesse nozioni anche se si tratta di un servizio di hosting dedicato.
Preparazione del database MySQL
Per interagire in modo “umano” con il database di MySQL, si fa riferimento all’interfaccia web phpMyAdmin, nel caso non l’aveste già disponibile sul vostro server si può banalmente installare da shell con il comando:
sudo apt-get install phpmyadmin
Di default per accedere all’interfaccia è sufficiente digitare da browser: http://localhost/phpmyadmin.
Vi rimando a questo interessante articolo riguardante l’uso di questa interfaccia, ma per chi non la conosce già premetto che è molto intuitiva e non serve un manuale d’uso.
Utilizzando il login di amministrazione del database su phpMyAdmin, creare un nuovo database, che per comodità chiameremo apns.
Creiamo una utenza che non avrà i diritti di root, ma che si limita ad operare solo all’interno del database apns appena creato. Questo passaggio non è essenziale, ma è fortemente suggerito per evitare di scrivere le credenziali di accesso dell’utente di root nel codice PHP che di solito sono più “riservate”.
Selezionare il database apns appena creato sulla colonna di sinistra, selezionare il tab “Privilegi” e cliccare quindi su “Aggiungi un nuovo utente”.
Nell’esempio seguente viene creato l’utente “testuser”, con password generata casualmente cliccando sul pulsante “Genera”.
Importante: salvarsi la password generata su blocco note per poterla poi indicare all’interno dei files PHP.
Nella sezione relativa ai “Privilegi Globali”, lasciare tutte le spunte deselezionate, in questo modo non si darà alcun grant globale a questo utente.
Cliccare sul pulsante “Esegui” in fondo alla pagina per eseguire l’operazione.
Ecco l’utente “testuser” comparire nell’elenco degli utenti di MySQL.
Eseguire lo script SQL di generazione della struttura delle tabelle che servono a EasyAPNS.
Spostarsi sul tab SQL e copiare/incollare il seguente codice:
SET FOREIGN_KEY_CHECKS=0;
CREATE TABLE `apns_device_history` (
`pid` int(9) unsigned NOT NULL auto_increment,
`clientid` varchar(64) NOT NULL,
`appname` varchar(255) NOT NULL,
`appversion` varchar(25) default NULL,
`deviceuid` char(40) NOT NULL,
`devicetoken` char(64) NOT NULL,
`devicename` varchar(255) NOT NULL,
`devicemodel` varchar(100) NOT NULL,
`deviceversion` varchar(25) NOT NULL,
`pushbadge` enum('disabled','enabled') default 'disabled',
`pushalert` enum('disabled','enabled') default 'disabled',
`pushsound` enum('disabled','enabled') default 'disabled',
`development` enum('production','sandbox') character set latin1 NOT NULL default 'production',
`status` enum('active','uninstalled') NOT NULL default 'active',
`archived` datetime NOT NULL,
PRIMARY KEY (`pid`),
KEY `clientid` (`clientid`),
KEY `devicetoken` (`devicetoken`),
KEY `devicename` (`devicename`),
KEY `devicemodel` (`devicemodel`),
KEY `deviceversion` (`deviceversion`),
KEY `pushbadge` (`pushbadge`),
KEY `pushalert` (`pushalert`),
KEY `pushsound` (`pushsound`),
KEY `development` (`development`),
KEY `status` (`status`),
KEY `appname` (`appname`),
KEY `appversion` (`appversion`),
KEY `deviceuid` (`deviceuid`),
KEY `archived` (`archived`)
) ENGINE=MyISAM DEFAULT CHARSET=utf8 COMMENT='Store unique device history';
CREATE TABLE `apns_devices` (
`pid` int(9) unsigned NOT NULL auto_increment,
`clientid` varchar(64) NOT NULL,
`appname` varchar(255) NOT NULL,
`appversion` varchar(25) default NULL,
`deviceuid` char(40) NOT NULL,
`devicetoken` char(64) NOT NULL,
`devicename` varchar(255) NOT NULL,
`devicemodel` varchar(100) NOT NULL,
`deviceversion` varchar(25) NOT NULL,
`pushbadge` enum('disabled','enabled') default 'disabled',
`pushalert` enum('disabled','enabled') default 'disabled',
`pushsound` enum('disabled','enabled') default 'disabled',
`development` enum('production','sandbox') character set latin1 NOT NULL default 'production',
`status` enum('active','uninstalled') NOT NULL default 'active',
`created` datetime NOT NULL,
`modified` timestamp NOT NULL default '0000-00-00 00:00:00' on update CURRENT_TIMESTAMP,
PRIMARY KEY (`pid`),
UNIQUE KEY `appname` (`appname`,`deviceuid`),
KEY `clientid` (`clientid`),
KEY `devicetoken` (`devicetoken`),
KEY `devicename` (`devicename`),
KEY `devicemodel` (`devicemodel`),
KEY `deviceversion` (`deviceversion`),
KEY `pushbadge` (`pushbadge`),
KEY `pushalert` (`pushalert`),
KEY `pushsound` (`pushsound`),
KEY `development` (`development`),
KEY `status` (`status`),
KEY `created` (`created`),
KEY `modified` (`modified`)
) ENGINE=MyISAM DEFAULT CHARSET=utf8 COMMENT='Store unique devices';
DELIMITER ;;
CREATE TRIGGER `Archive` BEFORE UPDATE ON `apns_devices` FOR EACH ROW INSERT INTO `apns_device_history` VALUES (
NULL,
OLD.`clientid`,
OLD.`appname`,
OLD.`appversion`,
OLD.`deviceuid`,
OLD.`devicetoken`,
OLD.`devicename`,
OLD.`devicemodel`,
OLD.`deviceversion`,
OLD.`pushbadge`,
OLD.`pushalert`,
OLD.`pushsound`,
OLD.`development`,
OLD.`status`,
NOW()
);;
DELIMITER ;
CREATE TABLE `apns_messages` (
`pid` int(9) unsigned NOT NULL auto_increment,
`clientid` varchar(64) NOT NULL,
`fk_device` int(9) unsigned NOT NULL,
`message` varchar(255) NOT NULL,
`delivery` datetime NOT NULL,
`status` enum('queued','delivered','failed') character set latin1 NOT NULL default 'queued',
`created` datetime NOT NULL,
`modified` timestamp NOT NULL default '0000-00-00 00:00:00' on update CURRENT_TIMESTAMP,
PRIMARY KEY (`pid`),
KEY `clientid` (`clientid`),
KEY `fk_device` (`fk_device`),
KEY `status` (`status`),
KEY `created` (`created`),
KEY `modified` (`modified`),
KEY `message` (`message`),
KEY `delivery` (`delivery`)
) ENGINE=MyISAM DEFAULT CHARSET=utf8 COMMENT='Messages to push to APNS';
Quindi cliccare sul tasto ESEGUI. A questo punto avrete tutta la struttura già perfettamente “adeguata”.
Niente di più semplice vero?
Potete trovare il file con lo script SQL a questo indirizzo.
Personalizzazione dei sorgenti PHP
La struttura dei sorgenti di EasyPHP è semplicissima ed è brevemente descritta di seguito:
Nella cartella “classes” sono presenti i files “class_APNS.php” e “class_DbConnect.php”, il primo file è quello che esegue in realtà quasi tutto il lavoro sporco, mentre il secondo si preoccupa di stabilire la connessione con il database.
Nella cartella radice, invece, sono presenti i files “apns.php” e “samples.php”, il primo file è quello che viene invocato dall’applicazione iOS quando si deve registrare il token del device, mentre il secondo racchiude una serie di esempi pratici su come si possono formare i messaggi di notifica verso i devices.
Utilizzare un client FTP per trasferire i sorgenti PHP e i 2 certificati sul server remoto, nel nostro esempio “/apns” rappresenta la cartella radice dei sorgenti (i certificati ed il file apns.php devono stare nella stessa cartella).
I 2 certificati devono essere posti con i flag degli attributi a 644 per maggiore sicurezza. Questa impostazione è obbligatoria, perché viene controllata all’interno del codice PHP, si può fare direttamente via FTP oppure da riga di comando:
sudo chmod 644 apns-dev.pem sudo chmod 644 apns.pem
I files su cui eseguire le personalizzazioni sono “class_APNS.php” e “apns.php”.
Su class_APNS.php vanno effettuati i seguenti interventi:
- Specificare il percorso assoluto del file di log
private $logPath = '/var/www/apns/apns.log'; //change this to your log absolute path
- Specificare il percorso assoluto del certificato di produzione
private $certificate = '/var/www/apns/apns.pem'; //change this to your production certificate absolute path
- Specificare il percorso assoluto del certificato di sviluppo
private $sandboxCertificate = '/var/www/apns/apns-dev.pem'; //change this to your development certificate absolute path
Nota: durante lo sviluppo e test class_APNS.php utilizza l’indirizzo del PNS Apple ssl://gateway.sandbox.push.apple.com:2195, mentre per la produzione viene utilizzato l’indirizzo ssl://gateway.push.apple.com:2195
Su apns.php vanno indicati i parametri di connessione al database alla riga 43:
$db = new DbConnect('localhost', 'testuser', 'Gj4fMDyS7PduwPRp', 'apns');
Nel file samples.php ci sono diversi esempi di come poter inviare una notifica al database del server APNs, io ho preferito fare il test solo con un esempio alla volta. Riporto quello che ho usato io, ma potete scegliere voi liberamente quale utilizzare.
show_errors();
// FETCH $_GET OR CRON ARGUMENTS TO AUTOMATE TASKS
$apns = new APNS($db);
/**
/* ACTUAL SAMPLES USING THE 'Examples of JSON Payloads' EXAMPLES (1-5) FROM APPLE'S WEBSITE.
* LINK: http://developer.apple.com/iphone/library/documentation/NetworkingInternet/Conceptual/RemoteNotificationsPG/ApplePushService/ApplePushService.html#//apple_ref/doc/uid/TP40008194-CH100-SW15
*/
// APPLE APNS EXAMPLE 2
$apns->newMessage(2, '2010-05-31 12:00:00'); // FUTURE DATE NOT APART OF APPLE EXAMPLE
$apns->addMessageAlert('Questo è un test di notifica push fatto da Gabriele Merlonghi', 'GUARDA');
$apns->addMessageBadge(5);
$apns->addMessageSound('chime');
$apns->addMessageCustom('acme', 'foo');
$apns->addMessageCustom('acme2', array('bang', 'whiz'));
$apns->queueMessage();
// SEND ALL MESSAGES NOW
$apns->processQueue();
?>
La programmazione lato server è terminata, ora non resta che occuparci della parte client, ovvero la parte che riguarda la vostra applicazione iOS.
Step 3: Preparazione dell’applicativo iOS per registrarsi alle notifiche.
Un dettaglio importante da sapere è che non è possibile testare le notifiche push con il simulatore, queste possono funzionare solo sul device fisico.
Premesso questo, ci sono tre cose fondamentali da fare nel progetto:
- Installare il profilo su Xcode e sul device di test
- Abilitare le notifiche push
- Prelevare il token del device ed inviarlo al server APNs precedentemente predisposto
Nelle linee guida Apple si raccomanda di prelevare il token ogni volta che viene avviata l’applicazione. Questo perché, in caso di ripristino del dispositivo, il token cambia, per cui se non viene aggiornato le notifiche push non arriveranno più su quel device.
Negli esempi seguenti si fa riferimento ad una versione modificata del progetto “Demo” che è fornito in EasyAPNS.
Abilitazione delle notifiche push
Il meccanismo di abilitazione è stato standardizzato da Apple e consiste nel tipico messaggio all’avvio dell’app che chiede all’utente:
“Questa applicazione vorrebbe inviarti delle notifiche:
Questo alert viene generato automaticamente da iOS, dopo che sul codice dell’app vengono scritte queste due righe di codice:
// Add registration for remote notifications
[application registerForRemoteNotificationTypes: UIRemoteNotificationTypeAlert | UIRemoteNotificationTypeBadge | UIRemoteNotificationTypeSound];
// Clear application badge when app launches
application.applicationIconBadgeNumber = 0;
in un punto qualsiasi all’interno nel metodo:
-(BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions
di DemoAppDelegate.m
Prelevamento del token ed invio al server
Rimanendo ancora all’interno dello stesso file DemoAppDelegate.m, aggiungere le seguenti righe di codice:
/*
* ---------------------------------------------------------------------
* BEGIN APNS CODE
* ---------------------------------------------------------------------
*/
/**
* Fetch and Format Device Token and Register Important Information to Remote Server
*/
- (void)application:(UIApplication *)application didRegisterForRemoteNotificationsWithDeviceToken:(NSData *)devToken {
#if !TARGET_IPHONE_SIMULATOR
NSLog(@"Did register for remote notifications: %@", devToken);
// Get Bundle Info for Remote Registration (handy if you have more than one app)
NSString *appName = [[[NSBundle mainBundle] infoDictionary] objectForKey:@"CFBundleDisplayName"];
NSString *appVersion = [[[NSBundle mainBundle] infoDictionary] objectForKey:@"CFBundleVersion"];
// Check what Notifications the user has turned on. We registered for all three, but they may have manually disabled some or all of them.
NSUInteger rntypes = [[UIApplication sharedApplication] enabledRemoteNotificationTypes];
// Set the defaults to disabled unless we find otherwise...
NSString *pushBadge = @"disabled";
NSString *pushAlert = @"disabled";
NSString *pushSound = @"disabled";
// Check what Registered Types are turned on. This is a bit tricky since if two are enabled, and one is off, it will return a number 2... not telling you which
// one is actually disabled. So we are literally checking to see if rnTypes matches what is turned on, instead of by number. The "tricky" part is that the
// single notification types will only match if they are the ONLY one enabled. Likewise, when we are checking for a pair of notifications, it will only be
// true if those two notifications are on. This is why the code is written this way
if(rntypes == UIRemoteNotificationTypeBadge){
pushBadge = @"enabled";
}
else if(rntypes == UIRemoteNotificationTypeAlert){
pushAlert = @"enabled";
}
else if(rntypes == UIRemoteNotificationTypeSound){
pushSound = @"enabled";
}
else if(rntypes == ( UIRemoteNotificationTypeBadge | UIRemoteNotificationTypeAlert)){
pushBadge = @"enabled";
pushAlert = @"enabled";
}
else if(rntypes == ( UIRemoteNotificationTypeBadge | UIRemoteNotificationTypeSound)){
pushBadge = @"enabled";
pushSound = @"enabled";
}
else if(rntypes == ( UIRemoteNotificationTypeAlert | UIRemoteNotificationTypeSound)){
pushAlert = @"enabled";
pushSound = @"enabled";
}
else if(rntypes == ( UIRemoteNotificationTypeBadge | UIRemoteNotificationTypeAlert | UIRemoteNotificationTypeSound)){
pushBadge = @"enabled";
pushAlert = @"enabled";
pushSound = @"enabled";
}
// Get the users Device Model, Display Name, Unique ID, Token & Version Number
UIDevice *dev = [UIDevice currentDevice];
NSString *deviceUuid = dev.uniqueIdentifier;
NSString *deviceName = dev.name;
NSString *deviceModel = dev.model;
NSString *deviceSystemVersion = dev.systemVersion;
// Prepare the Device Token for Registration (remove spaces and < >)
NSString *deviceToken = [[[[devToken description]
stringByReplacingOccurrencesOfString:@"<"withString:@""]
stringByReplacingOccurrencesOfString:@">" withString:@""]
stringByReplacingOccurrencesOfString: @" " withString: @""];
// Build URL String for Registration
// !!! CHANGE "www.mywebsite.com" TO YOUR WEBSITE. Leave out the http://
// !!! SAMPLE: "secure.awesomeapp.com"
NSString *host = @"www.mywebsite.com";
// !!! CHANGE "/apns.php?" TO THE PATH TO WHERE apns.php IS INSTALLED
// !!! ( MUST START WITH / AND END WITH ? ).
// !!! SAMPLE: "/path/to/apns.php?"
NSString *urlString = [@"/apns/apns.php?"stringByAppendingString:@"task=register"];
urlString = [urlString stringByAppendingString:@"&appname="];
urlString = [urlString stringByAppendingString:appName];
urlString = [urlString stringByAppendingString:@"&appversion="];
urlString = [urlString stringByAppendingString:appVersion];
urlString = [urlString stringByAppendingString:@"&deviceuid="];
urlString = [urlString stringByAppendingString:deviceUuid];
urlString = [urlString stringByAppendingString:@"&devicetoken="];
urlString = [urlString stringByAppendingString:deviceToken];
urlString = [urlString stringByAppendingString:@"&devicename="];
urlString = [urlString stringByAppendingString:deviceName];
urlString = [urlString stringByAppendingString:@"&devicemodel="];
urlString = [urlString stringByAppendingString:deviceModel];
urlString = [urlString stringByAppendingString:@"&deviceversion="];
urlString = [urlString stringByAppendingString:deviceSystemVersion];
urlString = [urlString stringByAppendingString:@"&pushbadge="];
urlString = [urlString stringByAppendingString:pushBadge];
urlString = [urlString stringByAppendingString:@"&pushalert="];
urlString = [urlString stringByAppendingString:pushAlert];
urlString = [urlString stringByAppendingString:@"&pushsound="];
urlString = [urlString stringByAppendingString:pushSound];
// Register the Device Data
// !!! CHANGE "http" TO "https" IF YOU ARE USING HTTPS PROTOCOL
NSURL *url = [[NSURL alloc] initWithScheme:@"http" host:host path:urlString];
NSURLRequest *request = [[NSURLRequest alloc] initWithURL:url];
NSData *returnData = [NSURLConnection sendSynchronousRequest:request returningResponse:nil error:nil];
NSLog(@"Register URL: %@", url);
NSLog(@"Return Data: %@", returnData);
#endif
}
/**
* Failed to Register for Remote Notifications
*/
- (void)application:(UIApplication *)application didFailToRegisterForRemoteNotificationsWithError:(NSError *)error {
#if !TARGET_IPHONE_SIMULATOR
NSLog(@"Fail to register for remote notifications: %@", error);
#endif
}
/**
* Remote Notification Received while application was open.
*/
- (void)application:(UIApplication *)application didReceiveRemoteNotification:(NSDictionary *)userInfo {
#if !TARGET_IPHONE_SIMULATOR
application.applicationIconBadgeNumber = 0;
self.textView.text = [userInfo description];
// We can determine whether an application is launched as a result of the user tapping the action
// button or whether the notification was delivered to the already-running application by examining
// the application state.
if (application.applicationState == UIApplicationStateActive) {
// Nothing to do if applicationState is Inactive, the iOS already displayed an alert view.
UIAlertView *alertView = [[UIAlertView alloc] initWithTitle:@"Did receive a Remote Notification"
message:[NSString stringWithFormat:@"The application received this remote notification while it was running:\n%@",
[[userInfo objectForKey:@"aps"] objectForKey:@"alert"]]
delegate:self
cancelButtonTitle:@"OK"
otherButtonTitles:nil];
[alertView show];
[alertView release];
}
NSLog(@"remote notification: %@",[userInfo description]);
NSDictionary *apsInfo = [userInfo objectForKey:@"aps"];
NSString *alert = [apsInfo objectForKey:@"alert"];
NSLog(@"Received Push Alert: %@", alert);
NSString *sound = [apsInfo objectForKey:@"sound"];
NSLog(@"Received Push Sound: %@", sound);
NSString *badge = [apsInfo objectForKey:@"badge"];
NSLog(@"Received Push Badge: %@", badge);
#endif
}
/*
* ---------------------------------------------------------------------
* END APNS CODE
* ---------------------------------------------------------------------
*/
Modificare la stringa:
NSString *host = @"www.mywebsite.com";
con l’URL corretta del server precedentemente predisposto.
Modificare inoltre la stringa:
NSString *urlString = [@"/apns/apns.php?".......
con il percorso del file apns.php (se avete seguito passo passo lo step precedente, non dovreste cambiare questa riga).
Ci possono essere due modi per effettuare la connessione al server APNs:
- in chiaro mediante protocollo HTTP
- in modo sicuro mediante protocollo HTTPS
Controllate di utilizzare il corretto protocollo per il vostro server indicandolo in questa riga:
NSURL *url = [[NSURL alloc] initWithScheme:@"http" host:host path:urlString];
Attenzione: nel caso di utilizzo del protocollo HTTPS (che io ritengo preferibile per ovvi motivi di sicurezza) dovete fare attenzione che il server disponga anche di certificato SSL valido, altrimenti la richiesta da iOS non andrà a buon fine.
Step 4: Prova finale
Tutti gli ingredienti sono al loro posto, non resta che provare a fare un test. Di seguito i passi e le verifiche da effettuare:
- Assicurarsi che il server APNs sia operativo e che tutti gli steps precedenti siano stati completati
- Per prima cosa occorre lanciare l’applicazione sul device iOS (se possibile, fatelo direttamente da Xcode in modo da vedere anche la finestra di Log, che è interessante analizzare).
- Con un’alert view, verrà richiesto di accettare che l’applicazione vi invii le notifiche (ovviamente dovete accettare).
- Sulla finestra di Log di Xcode si può osservare il messaggio “Did register for remote notifications: token number” che testimonia che il profilo con cui è stata compilata l’app è corretto ed abilitato alle notifiche, infatti avete ricevuto il numero del token della vostra applicazione
- Subito dopo viene fatta la registrazione del token (insieme a molti altri dati del device e dell’applicazione) sul server APNs. Lo potrete verificare sul Log con il messaggio “Register URL: tutta l’url completa che arriverà al server”
- Verificare se la tabella dei devices sul database è stata popolata con un nuovo elemento utilizzando phpMyAdmin.
Attenzione: un campo della tabella del device indica se quel device è di sviluppo oppure di produzione. Ai fini di questo tutorial (e delle vostre prove) occorre indicare manualmente che si tratta di un device di sviluppo. Per fare questo occorre aprire phpMyAdmin, andare sulla tabella “apns_devices” cliccare sull’unico record che dovrebbe essere presente (ovvero il device che è stato appena aggiunto). Cliccare su “Edit” e cambiare il campo “development type” da “production” a “sandbox”.Importante: Finché l’App viene compilata usando il development provisioning profile, è possibile ricevere delle notifiche solo dall’Apple sandbox server.
- Ora è possibile finalmente eseguire un test di notifica invocando da browser il file samples.php. Digitare quindi l’URL: http://www.vostroserverapns.com/apns/samples.php
Risorse
- Qui potete scaricare lo script dei comandi SQL per creare le tabelle del database.
- Qui potete scaricare i sorgenti PHP da personalizzare con i vostri dati.
- In arrivo anche il progetto completo Objective-C in Xcode 4.3.2.
- Qui potete consultare la documentazione originale di riferimento di Apple.
Un ringraziamento alla redazione di devAPP per avermi dato la possibilità di pubblicare questo tutorial sul blog. Non dimenticatevi di accedere anche al mio blog personale http://www.megabri.com e al portale delle mie App http://www.mgproductions.it.
Gabriele Merlonghi
Se avete problemi con il progetto presentato, questo è il link per scaricare il nostro esempio.
Vuoi ringraziare l’autore di questa guida?
Offrigli un caffè scaricando la sua applicazione 🙂
46 Responses to “T#110 – Come implementare le Push Notifications con EasyAPNS”
11 Giugno 2012
Tutorial sulle Push Notifications su DevAPP « TechnoHouse[…] Per maggiori dettagli vi rimando all’articolo sul blog di DevAPP. […]
16 Giugno 2012
GiovanniNaturalmente bisogna essere registrati come developer Apple vero?
Io che carico i miei sw senza certificarli perché ho il jb non funziona più come cosa?
Grazie,
Giovanni
23 Giugno 2012
DanyCiao, se creo il file .pem dal certificato di developer funziona tutto, ma per pubblicare l’app ho bisogno di farlo funzionare con il certificato di distribution quindi production, ma non funziona, suggerimenti??
11 Luglio 2012
FabrizioCiao ottimo articolo. Sto facendo le cose passo per passo e mi sono subito bloccato: inserisco il codice
// Add registration for remote notifications
[application registerForRemoteNotificationTypes: UIRemoteNotificationTypeAlert | UIRemoteNotificationTypeBadge | UIRemoteNotificationTypeSound];
// Clear application badge when app launches
application.applicationIconBadgeNumber = 0;
dentro il metodo specificato, faccio partire la simulazione ma non mi appare nessun alert… devo aggiungere altro codice?
11 Luglio 2012
Gabriele Merlonghi@Giovanni, certamente occorre essere sviluppatori iOS, infatti si può testare le push notification solo sul device fisico, non funziona sul simulatore.
@Dany, se hai testato con successo il funzionamento con il certificato di sviluppo, difficile pensare che con quello di produzione non funzioni. Nel database contolla il record relativo ad un device, c’è una flag che è relativa all’uso del certificato di svilupo piuttosto che di quello di produzione. Ovviamente devi accertarti anche che quello di produzione sia presente sul server.
@Fabrizio, come già indicato nell’articolo, non si può testare le push notification con il simulatore, ci vuole per forza il device fisico. Non l’ho deciso io, ma ovviamente è indicato e deciso da Apple stessa.
13 Luglio 2012
Fabriziook ora il codice sembra funzionare, si apre l’alert per richiedere l’ok alle notifiche push però sul database non aggiunge il device, ergo credo che non comunichi con il database nel server… cosa potrebbe essere?
il file di log dice:
———— inizio —————-
[13-Jul-2012 05:33:01] PHP Fatal error: Missing Production Certificate.
1) APNS::__construct -> File: apns.php (line 50)
2) APNS::checkSetup -> File: class_APNS.php (line 197)
3) APNS::_triggerError -> File: class_APNS.php (line 254)
in /home/u977973658/public_html/apns/classes/class_APNS.php on line 669
[13-Jul-2012 05:37:27] PHP Fatal error: Missing Production Certificate.
1) APNS::__construct -> File: apns.php (line 50)
2) APNS::checkSetup -> File: class_APNS.php (line 197)
3) APNS::_triggerError -> File: class_APNS.php (line 254)
in /home/u977973658/public_html/apns/classes/class_APNS.php on line 669
——- fine ———–
13 Luglio 2012
Fabriziook ho risolto.. era sbagliato l’url del .pem nel file class_APNS.php orsa si collega al database e inserisce il record nella tabella device. Non mi resta che fare una prova con uno degli esempi e vedere se funziona tutto
13 Luglio 2012
Gabriele MerlonghiOttimo Fabrizio, grazie del feedback.
13 Luglio 2012
Fabrizioaccidenti, avvio il file samples.php e ottengo il seguente errore:
Warning: mysqli::mysqli() [mysqli.mysqli]: (28000/1045): Access denied for user ‘u977973658_opera’@’localhost’ (using password: YES) in /home/u977973658/public_html/apns/classes/class_DbConnect.php on line 178
Connect failed: Access denied for user ‘u977973658_opera’@’localhost’ (using password: YES) There seems to have been a slight problem with our database, please try again later.
Non si collega al database… eppure le credenziali sono corrette! Infatti sono le stesse che ho settato nel file apns.php (li la connessione funziona e inserisce nel database tutti i dati relativi al device).
Quale potrebbe essere l’errore?
13 Luglio 2012
Gabriele Merlonghisi, infatti sul file di esempio sample.php e su apns.php anche io ho usato le stesse credenziali per l’accesso al db. Se hai già controllato questo, non saprei dove potrebbe essere l’errore sinceramente.
Dovrebbe funzionare
18 Luglio 2012
Fabriziobene ho risolto anche il problema della connessione.. sbagliavo l’host…
Comunque, ora si collega al database, inserisce i campi che deve inserire etc.. ma mi appare questo:
Warning: stream_socket_client() [function.stream-socket-client]: unable to connect to ssl://gateway.sandbox.push.apple.com:2195 (Connection timed out) in /home/u977973658/public_html/apns/classes/class_APNS.php on line 454
E’ possibile che l’hosting che uso ha la porta 2195 bloccata? Come free hosting sto utilizzando quello menzionato nell’articolo (freehostingnoads) …
Qualche consiglio?
26 Luglio 2012
MassimoSi il problema di Fabrizio secondo me dipende proprio dal provider che blocca la porta.
Io ho provato con Aruba e avevo lo stesso problema. Gli ho mandato una email e mi hanno confermato che la porta è chiusa.
Ho provato anche con FreeHostingNoAds e ho lo stesso errore.
Alla fine ho fatto funzionare il tutto utilizzando un mio serverino che raggiungo da internet attraverso il dns dinamico ( uso dyndns )
A questo proposito però ho una domanda : se il mio server risulta irraggiungibile la mia app all’avvio ( dato che cercherà di contattarlo per la registrazione ) rimane in freeze e poco dopo crasha. Questo aspetto come lo si risolve ? Può sempre capitare che non si riesca a raggiungere il server remoto . E se sono senza rete ? presumo vada fatta prima della registrazione un check della connettività , giusto ?
30 Luglio 2012
ValerioCiao a tutti,
sto seguendo la guida passo passo e mi sono inchiodato troppo presto…
ho comprato un server su iPage.com e nel pannello SQL ho copiato il blocco di codice SQL, premo esegui, e sorpresa: Mi da un errore di sintassi.
Questo è l’alert:
————————————————————————————————-
Errore
query SQL:
DELIMITER;
Messaggio di MySQL:
#1064 – You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near ‘DELIMITER’ at line 1
——————————————————————————————–
Ho controllato anche le versioni:
MySQL Version:
5.0.91-log
Perl Version:
5.8.8
PHP Version:
5.3.13
Non so come procedere. 🙁
Grazie in anticipo!
1 Agosto 2012
Gabriele Merlonghi@valerio attenzione a non fare il cut & paste dall’articolo pubblicato, perchè la formattazione può risultare non corretta, usa il file dei comandi SQL allegato all’articolo.
@fabrizio e @massimo sulla questione blocco delle porte ssl potreste avere ragione, anzi presumo che sia proprio questo il problema dato che avete avuto tempo di indagare più a fondo, al contrario di me che non ne ho avuto. Sinceramente ho citato questi servizi hosting a seguito di una ricerca su internet, ma non li ho testati personalmente. Anche io come Massimo ho usato un serverino mio personale per fare le prove.
@massimo riguardo alla raggiungibilità del server, certamente si può/deve fare un test di connettività prima di tentare di registrare il token. La cosa è piuttosto semplice, l’ho già fatto in una mia app (GPS Alarm Pro) per una ragione simile. Vi mando le indicazioni appena posso. Grazie del feedback, potrebbe essere effettivamente migliorato nel tutorial, aggiungendo appunto questo controllo.
1 Agosto 2012
Gabriele MerlonghiReachability.h e Reachability.m
Abstract: Basic demonstration of how to use the SystemConfiguration Reachablity APIs.
#import “Reachability.h”
Reachability *internetReach;
Reachability *wifiReach;
//controllo la connettività del device
NetworkStatus netStatus = [[Reachability reachabilityForInternetConnection] currentReachabilityStatus];
if ((netStatus == ReachableViaWWAN) || (netStatus == ReachableViaWiFi))
{
do connection;
}
questo è uno stralcio di codice che uso io, comunque il riferimento è questo: http://developer.apple.com/library/ios/#samplecode/Reachability/Introduction/Intro.html#//apple_ref/doc/uid/DTS40007324-Intro-DontLinkElementID_2
1 Agosto 2012
ValerioCiao Gabriele, grazie della risposta!
Purtroppo ho preso proprio il file allegato per lo script. Il mio problema è che nella versione SQL 5.0.19 ci sono delle differenze di sintassi (deduco) rispetto alla versione 5.0.2
Quello che crea problemi è la sintassi del Delimiter (credo siano i ;; che nelle precedenti versioni sono sostituiti dal simbolo | ) e l’istruzione CREATE TRIGGER, che non la legge in quanto probabilmente nella mia versione di SQL deve essere scritto in modo diverso…sto cercando la sintassi alternativa ma non trovo gran ché. 🙁
Se mi potete aiutare ve ne sarei immensamente grato, anche solo per sapere dove leggere sarebbe fantastico. (la guida MySQL non mi ha chiarificato molto le cose) Parla di dare i permessi SUPER all’account per abilitare il CREATE TRIGGER…ma non so come farlo. : /
7 Agosto 2012
ValerioSalve a tutti,
ho superato lo scoglio del MYSQL inserendo solo le due tabelle principali rinunciando alla tabella con lo storico dei device.
Finalmente sono arrivato al punto di provare la mia app! Parto con il testing e mi da un errore di compilazione a questa riga:
self.textView.text = [userInfo description];
L’errore è questo: Property “textview” not found on object of type “App Delegate *”
Sono ad un passo dalla fine, aiuto! 😀
Grazie in anticipo!
9 Agosto 2012
ValerioScusate non è molto carino fare un doppio post ma quanto è successo è davvero interessante. ^^
Ho rifatto tutto da zero, risistemato tutto passo passo.
Ho compiiato le parti interessate nell’ Appdelegate.m
(sto creando la app con phonegap, lavorando in Xcode)
Faccio il Run sul mio iphone di prova e Xcode mi allerta di un errore in giallo su:
NSString *deviceUuid = dev.uniqueIdentifier;
che lo da come deprecated. (credo comune a tutti dalla ios 5.0 in su)
Oltre questo nessun errore in xcode, mi installa la mia app sull’iphone, me la apre… nessun Alert per abilitare il push! O_O
Controllo sulla tabella mysql ed è vuota.
Non avendo altri errori non so proprio cosa fare. Ho ricontrollato 100 volte il codice:
// Add registration for remote notifications
[application registerForRemoteNotificationTypes: UIRemoteNotificationTypeAlert | UIRemoteNotificationTypeBadge | UIRemoteNotificationTypeSound];
// Clear application badge when app launches
application.applicationIconBadgeNumber = 0;
ed è all’interno del metodo:
-(BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions
(io l’ho copiato prima di “Return YES;” come suggerisce un utente del gruppo di Easy Apns)
Please Help! Sto cercando da due giorni e non trovo la soluzione…mi viene da pensare che non funziona easy Apns con cordova 🙁
Grazie per qualsiasi consiglio perché sto davvero in alto mare. -_-
9 Agosto 2012
Gabriele MerlonghiCiao Valerio, ho trovato il modo di risponderti solo adesso. Con PhoneGap non só darti garanzie di funzionamento. Mi spiace.
Faccio fatica con quello che mi scrivi capire cosa potrebbe non andare bene, peró posso aiutarti (forse anche gli altri) pubblicando il progetto completo che ho fatto io e su cui ho testato questo tutorial. Non l’ho fatto subito all’uscita dell’articolo perchè dovevo renderlo meno dipendente dalla mia implementazione personale. L’ho quasi ultimato e spero di passarlo ai redattori del blog a giorni.
10 Agosto 2012
ValerioGrazie Gabriele!
Intanto continuo a sperimentare con PhoneGap qualche soluzione, se trovo qualcosa che funziona la posto subito. 🙂
10 Agosto 2012
FilippoBellissimo tutorial!!!
Ho una semplice domanda, come faccio a switchare tra i certificati sandbox e normale?
grazie.
10 Agosto 2012
FilippoCiao,
Ho capito come switchare tra sandbox e normale, ma perché il Return Data è NULL?
ecco il log
http://localhost/EasyAPNs/apns.php?task=register&appname=………..
2012-08-10 17:58:39.216 iSteccone[2018:907] Return Data: (null)
11 Agosto 2012
Gabriele MerlonghiHo passato proprio adesso il progetto completo alla redazione di DevAPP, manca solo la pubblicazione ufficiale.
L’unica cosa da configurare (ovviamente) è l’indirizzo del server e l’eventuale percorso del file apsn.php.
Il progetto è fatto con Xcode 4.4.1 è funzionante sia su iPhone che su iPad, ma ricordo a tutti che non è possibile far funzionare le notifiche push sul simulatore, ci vuole il device fisico.
22 Agosto 2012
Giorgio NobileCiao Grabriele e grazie per la condivisione.
Lato server volevo segnalarvi la possibilità di usare i webservices di amazon, in particolare il servizio sqs (simple queue service http://aws.amazon.com/sqs/), se le notifiche generate dall’applicazione sono molte e per qualche motivo il backend vada giu sqs tiene in pancia quello che c’è da fare anche se il BE è down e lo scoda appena possibile.
Molto semplice da configurare e si paga in base all’uso.
Da pprovare assolutamente!
27 Agosto 2012
Gabriele MerlonghiOttima segnalazione Giorgio, credo che integreremo questa segnalazione all’interno del tutorial.
21 Gennaio 2013
Massimilianonon riesco a impostare il progetto con il mio certificato perchè ?
21 Gennaio 2013
Gabriele Merlonghiciao Massimiliano, servirebbe qualche dettaglio in più per poter indicare una eventuale soluzione
13 Aprile 2013
[iOs] Come configurare, inviare e ricevere le notifiche push in una app iOs | Francesco Ficetola[…] Come implementare le Push Notifications con EasyAPNS (devApp.com) […]
29 Agosto 2013
DavideSalve ho seguito il tutorial passo passo…tutto ok…il file di log non mi risulta nessun errore, solo che sul database vedo tutti gli utenti con i campi push sound, push badge tutti disable e mi sembra strano che su 300utenti nessuno abbia attivato le notifiche…inoltre le notifiche quando le invio sul database risulta delivered ma non arrivano, perchè? grazie
9 Settembre 2013
Gabriele MerlonghiCiao Davide, ci possono essere diversi motivi di malfunzionamento. Cerco di darti qualche dritta nella speranza che uno di questi possa essere quello che fa per te:
1) suppongo che tu stia in sviluppo, quindi devi usare il certificato di sviluppo sul server e devi ricordarti che per default, quando un nuovo utente si registra, easyapns imposta il certificato di produzione, quindi devi andare a cambiare l’impostazione a mano (come descritto nel tutorial)
2) tipicamente i campi push sound e push badge disable può dipendere o da un token non valido (che non è riuscito a registrarsi sul server di Apple) oppure perchè l’utente dell’app ha cliccato sul “rifiuto” di ricevere le push quando l’app glielo ha chiesto
3) hai già un db di 300 utenti ? ma con un singolo utente all’inizio dello sviluppo hai provato ? ti ha funzionato ?
4) ricordati che sul simulatore le notifiche non funzionano per policy di Apple, ci vuole un device vero
13 Settembre 2013
DavideCiao Gabriele, innanzitutto ti ringrazio per la risposta.
Comunque io ho provato le notifiche con il certificato di sviluppo con 1 solo device sul db ed ah funzionato perfettamente. Così ho mandato l’app su itunes e l’hanno accettata(ho messo anche sul server il certificato di produzione). Gli utenti la scaricano, e sul database sulle voci push sound, badge ho i campi con disable….Inoltre nel campo development ho tutti i device come “production”, il mio iphone ne ho 2 uno “production” e l’altro “sandbox”. Invio la notifica, la tabella apns_messages si popola, mi esce scritto anche delivered, ma non arriva nessuna notifica.
18 Settembre 2013
Gabriele MerlonghiCiao Davide,
quanto indichi onestamente non me lo spiego. Il fatto che le voci push sound, badge siano disabled è strano, dovrebbero essere disabled solo se l’utente ha negato l’autorizzazione alle push dell’app in questione, oppure se l’utente è andato specificatamente ad disabilitare le notifiche per la tua app.
Il fatto che ti prenda il device come “production” ti direi che è OK purchè venga fatto nel caso della app scaricata da Apple Store. Ovviamente se stai ancora debuggando con Xcode, per testare devi mettere a mano la proprietà a “sandbox”.
Ti suggerirei di fare altrettanto con i campi push sound e badge (abilitarli a mano).
Un altro suggerimento è il tempo di expiry del messaggio. Questo è settabile da dentro il codice PHP e ti suggerisco di metterlo piuttosto alto, (mi sembra che di default è impostato a 1 min). Questo significa che se al momento dell’invio della notifica (con il tuo server) il terminale si trovasse spento o non raggiungibile dalla network. La notifica non può temporaneamente essere consegnata, ma se il tuo expiration time è basso rischia di perdersi completamente.
15 Ottobre 2013
DAVIDEGrazie mille per la risposta, ma forae penso di aver trovato il problema, ricostruendo l’app per ios7 ho visto che durata il debug sul mio iphone mi esce questo errore:
“Fail to register for remote notifications: Error Domain=NSCocoaErrorDomain Code=3000 “nessuna stringa di autorizzazione ‘aps-environment’ valida trovata per l’applicazione” UserInfo=0x14e75d00 {NSLocalizedDescription=nessuna stringa di autorizzazione ‘aps-environment’ valida trovata per l’applicazione}”
Come posso risolvere? grazie mille
15 Ottobre 2013
Gabriele MerlonghiCiao Davide,
Questo errore è tipico quando non matcha il
certificato dello sviluppatore usato nella app con il provisioning profile creato sul dev center apple.
Fai attnezione che il provisioning profile deve essere abilitato a
gestire push notifications.
Fai attenzione anche al fatto di usare il certificato di sviluppo fintanto che debugghi la app nella configurazione di xcode.
25 Novembre 2013
DavideGentile Daniele, ho rifatto l’app, aggiornata per ios7 e sempre identico problema. Ovvero le persone adesso si registrano al database ed esce enabled o disabled in base alla configuarzione che settando dal device. Invece quando invio la notifica, non arriva nulla, controllo il file di log ed è vuoto, come se fosse stata inviata. Dal database mi risulta come delivered, ma non arriva nulla. Come mai? grazie mille
4 Giugno 2014
GianniBuongiorno,
è possibile creare un server che funzioni come APNs dato che ho una rete interna che non può accedere all’esterno?
9 Giugno 2014
Gabriele MerlonghiSalve Gianni, certamente che è possibile creare un server APNs per inviare le notifiche push versi gli iDevice. L’esempio presente in questo tutorial mostra la procedura esatta per configurare e preparare i messaggi verso il server Apple (che poi penserà a deliverare i messaggi verso gli iDevices) tuttavia non si preoccupa di quali “contenuti” inserire nel messaggio (a meno di un esempio) e “quando” triggerare l’invio. Questi due aspetti sono specifici della sua applicazione, quindi va fatta una implementazione indirizzata alla sua applicazione che può risiedere sempre sul server stesso ovviamente (nella maggior parte dei casi).
Almeno per manutentore il server. però, una forma di accesso alla rete esterna (internet) dovrà pur averla, altrimenti temo che potrà fare ben poco.
25 Giugno 2014
cri900Davide, hai risolto il tuo problema? Succede la stessa cosa anche a me. Push non arriva, i certificati sembrano essere tutti apposto, 0 errori nel log e i database si popolano normalmente…
1 Luglio 2014
Gabriele MerlonghiCiao Davide,
tutta la procedura per far funzionare le notifiche ha numerosi step e anche insidiosi, ma ti posso garantire che se seguita alla lettera porta ad un risultato positivo.
23 Luglio 2014
MircoCiao a tutti,
Avrei bisogno di sapere se EasyAPNS funziona ancora??
23 Luglio 2014
Gabriele MerlonghiCiao Mirco, è da un pó che non lo uso (il mio tutorial intendo) e quindi verificheró.
Ci sono degli aggiornamenti lato Apple che ti fanno pensare che possano non funzionare più cosi come imlementate ?
14 Agosto 2014
MIrcoCiao Gabriele,
ho visto solo la data di pubblicazione del tutorial…quindi prima di mettermi a leggere il tutto ho preferito chiedere…
ciao ciao.
Mirco.
Grazie ancora.
21 Agosto 2014
MIrcoCiao a tutti,
una domanda…il file apns.pem…quando lo creo???
io mi ritrovo solo il certificato apns-dev.pem
25 Agosto 2014
Gabriele MerlonghiCiao Mirco, il certificato apns.pem (che convenzionalmente ci si intende quello di produzione perché non ha il -dev sul nome) si genera con la stessa procedura di quelli per lo sviluppo, ma ovviamente va utilizzato solo quando si va in produzione, con la app approvata da Apple.
17 Settembre 2014
Dario De LeonardisCiao Gabriele e grazie per la tua splendida guida.
Ho seguito i vari passaggi ma una volta avviato il progetto ricevo questo messaggio:
Return Data: #!/usr/bin/php
Puoi aiutarmi?? Grazie mille ancora
18 Dicembre 2014
MIcheleIntanto complimenti per questa splendida guida.
Attenzione: nel caso di utilizzo del protocollo HTTPS (che io ritengo preferibile per ovvi motivi di sicurezza) dovete fare attenzione che il server disponga anche di certificato SSL valido, altrimenti la richiesta da iOS non andrà a buon fine…
Domanda: è ancora così?
Grazie 🙂