Related
Since I started my Codification Theory course, I've started to feel curious about practical implementations of information theory algorithms. I've researched about Huffman code and how this is used for data compress. I am specially curious about building an image (JPG, JPEG) compressor using Huffman codes but I'm struggling in the implementation.
My idea for this program goes like this:
1. Implement a HuffmanCode class, which is used to encode and decode a string input (Find the char frequency for all characters in string, build Huffman tree, generate Huffman code, etc.). I found this implementation "here".
2. Having the Huffman code implementation, I read an image input and convert it to a byte array. Then, I use this byte array to build a string having all of these bytes. Now, I apply the Huffman code for the previous string.
3. The result of the previous step is a binary string, then I convert this binary string to a byte array.
4. Finally, write the corresponding image to the previous byte array and output.
Following this reasoning, I got a RasterFormatException : Data array too small (should be > 749999 ). I've tried others implementations for writing the image but I am still getting some other Exceptions such as image == null exception.
I was wondering if someone has a better approach for building this program, or if I am missing something related to writing/reading images in Java (I'm new with this tools), or if I am misunderstanding something related to Huffman codes.
The HuffmanCode class is the following (I made some changes):
public class HuffmanCode {
public static void main(String[] args){
String test = "AndersonAndresLlanosQuintero";
System.out.println(countFrequency(test));
}
// Clase nodo para las construcción del árbol.
class HuffmanNode{
public int frecuencia;
public char caracter;
public HuffmanNode leftNode;
public HuffmanNode rightNode;
public HuffmanNode(){}
public int getFrecuencia() {
return frecuencia;
}
public void setFrecuencia(int frecuencia) {
this.frecuencia = frecuencia;
}
public char getCaracter() {
return caracter;
}
public void setCaracter(char caracter) {
this.caracter = caracter;
}
public HuffmanNode getLeftNode() {
return leftNode;
}
public void setLeftNode(HuffmanNode leftNode) {
this.leftNode = leftNode;
}
public HuffmanNode getRightNode() {
return rightNode;
}
public void setRightNode(HuffmanNode rightNode) {
this.rightNode = rightNode;
}
}
// Clase comparadora para saber cuando un nodo está por encima de otro.
class HuffmanComparator implements Comparator<HuffmanNode> {
public int compare(HuffmanNode x, HuffmanNode y) {
return x.frecuencia - y.frecuencia;
}
}
/* Procedemos a implementar el algoritmo : */
/* Necesitaremos la raíz del árbol de Huffman y un Map para
hacer match entre un símbol y su frecuencia de aparición.
*/
private Map<Character,String> charToBinaryMap;
private HuffmanNode root;
private String nuevaSalida;
public HuffmanNode getRoot(){
return this.root;
}
public String getNuevaSalida(){
return this.nuevaSalida;
}
public HuffmanCode(){
this.root = null;
this.charToBinaryMap = new HashMap<Character, String>();
}
public HuffmanNode getTree(){
return this.root;
}
/* Teniendo el código de Huffman, decodificar simplemente asigna a cada arista
* del árbol el símbolo de 0 o 1. Para esta implementación, las aristas a la izq.
* tendrán el símbolo "0" y para la derecha el símbolo "1". */
public String Decodificar(String binaryString, HuffmanNode root){
HuffmanNode current = root;
StringBuilder build = new StringBuilder();
for(int i = 0; i < binaryString.length(); i++){
if(current != null){
if((current.rightNode == null && binaryString.charAt(i) == '1') || (current.leftNode == null && binaryString.charAt(i) == '0')){
i--;
build.append(current.caracter);
current = root;
continue;
}
if(binaryString.charAt(i) == '1'){
current = current.rightNode;
}else {
current = current.leftNode;
}
}
}
if(current != null){
build.append(current.caracter);
}
return build.toString();
}
/*Codificar : Crear el árbol más óptimo para nuestra cadena de bits. */
public String Codificar(String strToCode){
Map<Character, Integer> charOcurrence = countFrequency(strToCode);
int n = charOcurrence.size();
/* Creamos una cola de prioridad con el mapeo de la ocurrencia de símbolos
que organice los símbolos de acuerdo al comparador de Huffman. */
PriorityQueue<HuffmanNode> huffmanHeap = new PriorityQueue<>(n, new HuffmanComparator());
// Recorremos el HashMap y creamos la cola de prioridad de acuerdo a la frecuencia del símbolo:
charOcurrence.forEach((key, value) -> {
HuffmanNode node = new HuffmanNode();
node.caracter = key;
node.frecuencia = value;
node.leftNode = null;
node.rightNode = null;
huffmanHeap.add(node);
});
/* Transformamos la cola prioritaria (minHeap) en un árbol de Huffman mediante
el algoritmo visto en clase. */
while(huffmanHeap.size() > 1){
HuffmanNode leaf1 = huffmanHeap.peek();
huffmanHeap.poll();
HuffmanNode leaf2 = huffmanHeap.peek();
huffmanHeap.poll();
HuffmanNode ptr = new HuffmanNode();
ptr.frecuencia = leaf1.frecuencia + leaf2.frecuencia;
ptr.caracter = '-';
ptr.leftNode = leaf1;
ptr.rightNode = leaf2;
huffmanHeap.add(ptr);
}
this.root = huffmanHeap.peek();
/* Teniendo el árbol de Huffman, buscamos las palabras código
y mostramos al usuario como se han codificado los símbolos : */
System.out.println(" Caracter | Palabra Código | Frecuencia");
System.out.println("----------------------------------");
codeWords(root, "");
/* Codificamos el input con las nuevas palabras código obtenidas : */
StringBuilder build = new StringBuilder();
for(Character ch : strToCode.toCharArray()){
build.append(this.charToBinaryMap.get(ch));
}
this.nuevaSalida = build.toString();
int pesoOriginal = strToCode.getBytes().length*8;
int pesoComprimido = nuevaSalida.length();
System.out.println("Peso original (bits) :" + pesoOriginal);
/*System.out.println("Codificación de Huffman: " + nuevaSalida);
*/
System.out.println("Longitud de la codificación de Huffman: " + nuevaSalida.length());
System.out.println("Peso post-codificación: " + pesoComprimido);
return nuevaSalida;
}
/* countFrequency : Cuenta número de ocurrencias de un caracter. */
public static Map<Character, Integer> countFrequency(String input){
HashMap<Character, Integer> mapFrequency = new HashMap<>();
for(int i = 0; i < input.length(); i++){
if(!mapFrequency.containsKey(input.toCharArray()[i])){
mapFrequency.put(input.toCharArray()[i], 1);
}else{
mapFrequency.put(input.toCharArray()[i], mapFrequency.get(input.toCharArray()[i])+1);
}
}
return mapFrequency;
}
/* Como queremos las hojas del árbol de Huffman, hacemos un simple
* recorrido in-order sobre el árbol, imprimiendo únicamente las hojas. */
public void codeWords(HuffmanNode root, String str){
if(root.leftNode != null){
codeWords(root.leftNode, str + 0);
}
if(root.leftNode == null && root.rightNode == null){
this.charToBinaryMap.put(root.caracter, str);
System.out.println(root.caracter + " | " + str + " | " + root.frecuencia);
return;
}
if(root.rightNode != null){
codeWords(root.rightNode, str + 1);
}
}
public String charList(HuffmanNode root, String str){
if(root.leftNode != null){
charList(root.leftNode, str);
}
if(root.leftNode == null && root.rightNode == null){
str = str + root.caracter;
}
if(root.rightNode != null){
charList(root.rightNode, str);
}
return str;
}
}
The ImageProcessing class, where the whole reasoning is developed, is the following:
import java.awt.*;
import java.awt.color.ColorSpace;
import java.awt.image.*;
import java.io.*;
import java.math.BigInteger;
import java.nio.charset.Charset;
import java.nio.charset.StandardCharsets;
import javax.imageio.ImageIO;
public class ImageProcessing {
public static void main(String args[]) throws Exception{
/* Convert image to byte array and then, to a string */
StringBuilder build = new StringBuilder();
BufferedImage bImage = ImageIO.read(new File("/WorkSpace/HuffmanCompression/src/draken.jpg"));
ByteArrayOutputStream bos = new ByteArrayOutputStream();
ImageIO.write(bImage, "jpg", bos );
byte [] data = bos.toByteArray();
for(int i = 0; i < data.length; i++){
build.append(data[i]);
}
/* Use Huffman code to the previous string.*/
HuffmanCode huffman = new HuffmanCode();
String prueba = huffman.Codificar(build.toString());
String pruebaDecodificada = huffman.Decodificar(prueba, huffman.getTree());
String strToByte = huffman.getNuevaSalida();
/*
String inputString = strToByte;
Charset dictionaryMap = StandardCharsets.UTF_16;
byte[] newImage = inputString.getBytes(dictionaryMap);
*/
/*Convert the binary string to a byte array and then, output the corresponding image. I copied and paste this part of the code from this blog. */
byte[] bval = new BigInteger(strToByte, 2).toByteArray();
OutputStream stream = new FileOutputStream("output.jpg");
BufferedImage image = createRGBImage(bval, bImage.getWidth(), bImage.getHeight());
try {
ImageIO.write(image, "jpg", stream);
}
finally {
stream.close();
}
}
public static BufferedImage createRGBImage(byte[] bytes, int width, int height) {
DataBufferByte buffer = new DataBufferByte(bytes, bytes.length);
ColorModel cm = new ComponentColorModel(ColorSpace.getInstance(ColorSpace.CS_sRGB), new int[]{8, 8, 8}, false, false, Transparency.OPAQUE, DataBuffer.TYPE_BYTE);
return new BufferedImage(cm, Raster.createInterleavedRaster(buffer, width, height, width * 3, 3, new int[]{0, 1, 2}, null), false, null);
}
}
I will be grateful if someone can help me, Thanks in advance!
When I send a token it works, but when I send a request to receive data the function getheader() returns null.
public class JWTAuthorizationFilter extends OncePerRequestFilter{
#Override
protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain)
throws ServletException, IOException {
//recuperer de la requete envoyer dans jwt le header du token
String jwt =request.getHeader(SecurityConstants.HEADER_STRING);
System.out.println("authori");
System.out.println(jwt);
if(jwt==null ) {
//faire le filtre
filterChain.doFilter(request, response);
return;
}
Claims claims=Jwts.parser()
.setSigningKey(SecurityConstants.SECRET)//signer avec le secret
//parser et remplace le TOKEN_PREFIX par chaine vide
.parseClaimsJws(jwt.replaceAll(SecurityConstants.TOKEN_PREFIX, ""))
//recuper le corps du token
.getBody();
String username =claims.getSubject();
//returne tableau d'objet qui contient les roles du user
ArrayList<Map<String,String>> roles=(ArrayList<Map<String,String>>) claims.get("role");
Collection<GrantedAuthority> authorities=new ArrayList<>();
//parcourire et recuperer les role de mon token
roles.forEach(r->{
authorities.add(new SimpleGrantedAuthority(r.get("authority")));
});
//mettre dans authenticatedUserToken le nom et authoriter d'un utilisateur authentifier dans le token
UsernamePasswordAuthenticationToken authenticatedUserToken=
new UsernamePasswordAuthenticationToken(username,null,authorities);
//charger l'identiter dans le context de l'application
SecurityContextHolder.getContext().setAuthentication(authenticatedUserToken);
filterChain.doFilter(request, response);
}
}
this is from securConfigure
http.addFilter(new JWTAuthenticationFilter(authenticationManager()))
.addFilterBefore(new JWTAuthorizationFilter(),UsernamePasswordAuthenticationFilter.class);
Here I sent authentification everything ok I get my token:
Here I try to get service:
Here what test console in JWTAuthorization display where I call resquest.getHeader()
In your endpoint it looks like http://localhost:8080/tasks is authenticating with JWT(its being passed in correctly and authenticated).
The response headers to ./tasks should not include the Header "Authorization" in it's response...I don't see why you would need this after authentication.
Is there already ANY solution how to insert/edit/delete events in google Calendar using Zend Gdata Framework.
Since November 17 it doesn't work.
Thanks
First you have to follow this step:
http://cornempire.net/2012/01/08/part-2-oauth2-and-configuring-your-application-with-google/
When it's done you can use my class : !! Curl has to be enable on your server.
class gcalendar{
private $cal_id;
//To get credentials follow this steps ==> http://cornempire.net/2012/01/08/part-2-oauth2-and-configuring-your-application-with-google/
private $client_secret='to_change';//TO CHANGE
private $refresh_token='to_change';//TO CHANGE
private $client_id='to_change';//TO CHANGE
public $spindle='+01:00';
private $token;
public function __construct($cal_id){
$this->token=$this->get_access_token();
$this->cal_id=$cal_id;
}
//Retourne un token
private function get_access_token(){
$tokenURL = 'https://accounts.google.com/o/oauth2/token';
$postData = array(
'client_secret'=>$this->client_secret,
'grant_type'=>'refresh_token',
'refresh_token'=>$this->refresh_token,
'client_id'=>$this->client_id
);
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $tokenURL);
curl_setopt($ch, CURLOPT_POST, 1);
curl_setopt($ch, CURLOPT_POSTFIELDS, $postData);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
$tokenReturn = curl_exec($ch);
$token = json_decode($tokenReturn);
$accessToken = $token->access_token;
return $accessToken;
}
//liste tous les events sur la période définit en param
public function list_events($start_date,$end_date){
return $this->execute('list_events',false,array('start_date'=>$start_date,'end_date'=>$end_date));
}
//Récupere l'event ayant l'id passer en param
public function get_event($event_id){
return $this->execute('get_event',false,array('event_id'=>$event_id));
}
//Ajoute un event !!Attention$_data doit respecter une certaine syntaxe voir plus bas fonction create_args!
public function add_event($_data){
$args=$this->create_args($_data);
return($this->execute('add_event',$args));
}
//Modifie un rdv (heures, titre ou contenu).
public function update_event($event_id,$_data){
$ev=json_decode($this->get_event($event_id));
$_data['sequence']=$ev->sequence+1;
$args=$this->create_args($_data);
return($this->execute('update_event',$args,array('event_id'=>$event_id)));
}
//Supprime un event
public function delete_event($event_id){
return $this->execute('delete_event',false,array('event_id'=>$event_id));
}
/*
** $_data=array(
!start_date => Date de début de l'event au format Y-m-d
!start_time => Heure de début de l'event au format HH:ii
!end_date => Date de fin de l'event Y-m-d
!end_time => Heure de fin de l'event HH:ii
summary => Titre de l'event (title)
description => Description de l'event
sequence => Sequence de l'event (C'est un numéro à incrémenter à chaque update de l'event). Obligatoire lors d'un update.
)
Les champs avec un ! sont obligatoires!
**
*/
private function create_args($_data){
$_args=array( 'start' => array('dateTime'=>$_data['start_date']."T".$_data['start_time'].":00.000".$this->spindle),
'end' => array('dateTime'=>$_data['end_date']."T".$_data['end_time'].":00.000".$this->spindle));
unset($_data['start_date']);
unset($_data['start_time']);
unset($_data['end_date']);
unset($_data['end_time']);
foreach($_data as $key=>$value){
$_args[$key]=$value;
}
return json_encode($_args);
}
//execute les requetes curl adaptée selon le type ($type_exe)
private function execute($type_exe,$args=false,$opt=false){
switch ($type_exe){
case 'list_events':
$request='https://www.googleapis.com/calendar/v3/calendars/'.urlencode($this->cal_id).'/events?timeMax='.urlencode($opt['end_date'].'T23:59:59.000'.$this->spindle).'&timeMin='.urlencode($opt['start_date'].'T00:00:01.000'.$this->spindle);
$session = curl_init($request);
break;
case 'get_event':
$request='https://www.googleapis.com/calendar/v3/calendars/'.urlencode($this->cal_id).'/events/'.$opt['event_id'];
$session = curl_init($request);
break;
case 'add_event':
$request='https://www.googleapis.com/calendar/v3/calendars/'.urlencode($this->cal_id).'/events';
$session = curl_init($request);
curl_setopt ($session, CURLOPT_POST, true);
break;
case 'update_event':
$request = 'https://www.googleapis.com/calendar/v3/calendars/'.urlencode($this->cal_id).'/events/'.$opt['event_id'];
$session = curl_init($request);
curl_setopt($session, CURLOPT_CUSTOMREQUEST, "PUT");
break;
case 'delete_event':
$request='https://www.googleapis.com/calendar/v3/calendars/'.urlencode($this->cal_id).'/events/'.$opt['event_id'];
$session = curl_init($request);
curl_setopt($session, CURLOPT_CUSTOMREQUEST, "DELETE");
break;
}
if($args){
curl_setopt ($session, CURLOPT_POSTFIELDS, $args);
}
curl_setopt($session, CURLOPT_HEADER, false);
curl_setopt($session, CURLOPT_RETURNTRANSFER, true);
curl_setopt($session, CURLOPT_VERBOSE, true);
curl_setopt($session, CURLINFO_HEADER_OUT, true);
curl_setopt($session, CURLOPT_HTTPHEADER, array('Content-Type: application/json','Authorization: Bearer ' . $this->token,'X-JavaScript-User-Agent: My_company'));
$response = curl_exec($session);
curl_close($session);
return $response;
}
}
And this is how you can use it
//How to use the class:
$gcal=new gcalendar('**calendar_id**');//TO CHANGE
// Add an event
$result=$gcal->add_event(array('start_date'=>'2014-11-20','start_time'=>'12:00','end_date'=>'2014-11-20','end_time'=>'14:00','summary'=>'My event','description'=>'The desc of my event'));
//List events between two dates
// $result=$gcal->list_events('2014-11-01','2014-11-30');
//update an event with ID
// $result=$gcal->update_event('ID_OF_EVENT',array('start_date'=>'2014-11-20','start_time'=>'12:00','end_date'=>'2014-11-20','end_time'=>'14:00','summary'=>'Rdv banane','description'=>'Ceci est une banane'));
//Delete an event with ID
// $result=$gcal->delete_event('ID_OF_EVENT');
//Display result
$res=json_decode($result);
print_r($res);
Hope it will help. If you have any question...
//How to use the class:
$gcal=new gcalendar('**your_mail_adress**');//TO CHANGE
It's not your mail adress here but your calendar id
I have a CheckBoxCell I want to add my CellTable but not when I'm wrong because when I run it does not show me the Check
THIS IS MY CODE
public class TablaEntryPoint extends Composite implements EntryPoint{
private SingleSelectionModel sm = new SingleSelectionModel();
{
// Añade un objeto que recibe notificaciones cuando cambia la selección.
sm.addSelectionChangeHandler(new SelectionChangeEvent.Handler() {
#Override
public void onSelectionChange(SelectionChangeEvent event) {
AuxParametro c = sm.getSelectedObject();
if (c != null) {
Window.alert(c.getNomParametro());
}
}
});
}
/** La tabla trabaja por páginas. En este caso la longitud de página se pasa en el
* constructor. También hay un constructor sin parámetros que define una longitud
* por defecto de 15 renglones por página. */
private final CellTable<AuxParametro> tblConocidos = new CellTable<AuxParametro>(10);
{
// asigna el objeto que controla las selecciones.
tblConocidos.setSelectionModel(sm);
// Agrega columnas.
// Columna numérica. El constructor de "NumberCell"puede recibir un"NumberFormat".
tblConocidos.addColumn(new Column<AuxParametro, Number>(new NumberCell()) {
{
setHorizontalAlignment(HasAlignment.ALIGN_RIGHT);
}
#Override
public Long getValue(final AuxParametro objeto) {
return objeto.getIdParametro();
}
}, "ID Unico");
// Columna de texto fijo con encabezado y pie de página.
tblConocidos.addColumn(new TextColumn<AuxParametro>() {
#Override
public String getValue(final AuxParametro objeto) {
return objeto.getNomParametro();
}
}, "Nombre Parametro");
/* Columna modificable. El método "update" de la interfaz "FieldUpdater" recibe
* los cambios a un objeto de la columna. */
tblConocidos.addColumn(new Column<AuxParametro,String>(new TextInputCell()) {
{
/* Asigna la referencia al objeto que recibe las notificaciones de cambio. */
setFieldUpdater(new FieldUpdater<AuxParametro, String>() {
#Override
public void update(int index, AuxParametro objeto, String valor) {
objeto.setCodContable(Integer.parseInt(valor));
}
});
}
#Override
public String getValue(final AuxParametro objeto) {
return String.valueOf(objeto.getCodContable());
}
}, "Codigo Contable");
// Columna de fecha.
tblConocidos.addColumn(new Column<AuxParametro, Number>(new NumberCell()) {
#Override
public Integer getValue(final AuxParametro objeto) {
return objeto.getCodUno();
}
}, "Codigo Uno");
// Columna de fecha.
tblConocidos.addColumn(new Column<AuxParametro, Number>(new NumberCell()) {
#Override
public Integer getValue(final AuxParametro objeto) {
return objeto.getCodDos();
}
}, "Codigo Dos");
Column<AuxParametro, Boolean> checkColumn = new Column<AuxParametro, Boolean>(
new CheckboxCell(true, false)) {
#Override
public Boolean getValue(AuxParametro object) {
// Get the value from the selection model.
return sm.isSelected(object);
}
};
tblConocidos.addColumn(checkColumn, SafeHtmlUtils.fromSafeConstant("<br/>"));
}
private final SimplePager pager = new SimplePager();
{
pager.setDisplay(tblConocidos);
}
public TablaEntryPoint(List<AuxParametro> tabla) {
ListDataProvider<AuxParametro> dataProvider = new ListDataProvider<AuxParametro>(tabla);
dataProvider.addDataDisplay(tblConocidos);
FlowPanel panel = new FlowPanel();
panel.add(new Label("Seleccione un contacto o edite su teléfono."));
panel.add(tblConocidos);
panel.add(pager);
initWidget(panel);
}
public void onModuleLoad() {
RootPanel.get().add(this);
}
}
I think you need to set the column width for each of your columns. If you look at the GWT showcase CellTable example (here) you can see that the checkbox column width is set with the statement cellTable.setColumnWidth(checkColumn, 40, Unit.PX).
I’m trying to implement an Android app with GCM (Google Cloud Messaging).
My specific Server is written by PHP and my Client is an Android app.
Push notification messages are received well when the app is running. The logcat is this:
07-28 07:49:56.991: V/GCMBroadcastReceiver(13254): onReceive: com.google.android.c2dm.intent.RECEIVE
07-28 07:49:56.991: V/GCMRegistrar(13254): Setting the name of retry receiver class to com.appacoustic.android.g.gcm.GGCMBroadcastReceiver
07-28 07:49:57.011: D/GGCMBroadcastReceiver(13254): Servicio: com.appacoustic.android.g.gcm.GGCMIntentService
07-28 07:49:57.011: V/GCMBroadcastReceiver(13254): GCM IntentService class: com.appacoustic.android.g.gcm.GGCMIntentService
07-28 07:49:57.021: V/GCMBaseIntentService(13254): Intent service name: GCMIntentService-<<<MyProjectNumber>>>-1
07-28 07:49:57.026: D/GGCMIntentService(13254): Mensaje recibido: <<<MySendedMessage>>>
but when it is stopped (not paused), if I send a message from the host, appears the typical Toast crash.
The logcat error is this:
07-28 07:50:06.381: V/GCMBroadcastReceiver(13294): onReceive: com.google.android.c2dm.intent.RECEIVE
07-28 07:50:06.386: V/GCMRegistrar(13294): Setting the name of retry receiver class to com.appacoustic.android.g.gcm.GGCMBroadcastReceiver
07-28 07:50:06.386: D/GGCMBroadcastReceiver(13294): Servicio: com.appacoustic.android.g.gcm.GGCMIntentService
07-28 07:50:06.386: V/GCMBroadcastReceiver(13294): GCM IntentService class: com.appacoustic.android.g.gcm.GGCMIntentService
07-28 07:50:06.396: D/AndroidRuntime(13294): Shutting down VM
07-28 07:50:06.396: W/dalvikvm(13294): threadid=1: thread exiting with uncaught exception (group=0x4163bc50)
07-28 07:50:06.401: E/AndroidRuntime(13294): FATAL EXCEPTION: main
07-28 07:50:06.401: E/AndroidRuntime(13294): Process: com.planetdevices.android.loyalty, PID: 13294
07-28 07:50:06.401: E/AndroidRuntime(13294): java.lang.RuntimeException: Unable to instantiate service com.appacoustic.android.g.gcm.GGCMIntentService: java.lang.NullPointerException
I guess the issue is about wake up the Service, but actually I test too much things and I am really confused and exhausted…
I have made a package in a library project to implement GCM. The code is this:
GGCMIntentService.java
package com.appacoustic.android.g.gcm;
...
/**
* #author AppAcoustiC <p>
* Servicios GCM. Básicamente son todo callbacks.
*/
public class GGCMIntentService extends GCMBaseIntentService {
private static final String tag = "GGCMIntentService";
/**
* Constructor.
*/
public GGCMIntentService() {
super(SENDER_ID); // Llamamos a la superclase
} // GGCMIntentService()
/**
* Es lo que hace al registrarse el dispositivo.
*/
#Override
protected void onRegistered(Context context, String registrationId) {
Log.i(tag, "Dispositivo registrado: regId = " + registrationId);
Log.d("name: ", GGCM.name);
Log.d("email: ", GGCM.email);
displayMessage(context, getString(R.string.gcm_registered)); // Mostramos un mensaje informativo por pantalla
GServerUtilities.register(context, registrationId, GGCM.name, GGCM.email); // Nos registramos en nuestro Servidor dedicado (Planet Devices)
} // onRegistered()
/**
* Es lo que se hace al eliminar el registro.
*/
#Override
protected void onUnregistered(Context context, String registrationId) {
Log.i(tag, "Eliminado el registro del dispositivo.");
displayMessage(context, getString(R.string.gcm_unregistered)); // Mostramos un mensaje informativo por pantalla
if (GCMRegistrar.isRegisteredOnServer(context)) { // Si ya está registrado en nuestro Servidor
GServerUtilities.unregister(context, registrationId); // Se desregistra de éste
} else {
// Este callback se hace al tratar de borrar el registro desde la clase ServerUtilities cuando el registro en el Servidor falla
Log.i(tag, "Se ha ignorado el callback de anulación de registro.");
}
} // onUnregistered()
/**
* Notificación recibida.
*/
#Override
protected void onMessage(Context context, Intent intent) {
String message = intent.getStringExtra(GCommonUtilities.EXTRA_MESSAGE); // Recojo el mensaje
Log.d(tag, "Mensaje recibido: " + message);
displayMessage(context, message); // Lo mostramos por pantalla
generateNotification(context, message); // Se lo notificamos al usuario (mensaje emergente)
} // onMessage()
/**
* Cuando se borran los mensajes.
*/
#Override
protected void onDeletedMessages(Context context, int total) {
Log.i(tag, "Recibida la notificación de mensajes eliminados.");
String message = getString(R.string.gcm_deleted, total); // Recojo el string y el nº de mensajes borrados SERÁ SIEMPRE EL MISMO STRING AL COGERLO DE LOS R.STRING ???
displayMessage(context, message); // Lo mostramos por pantalla
generateNotification(context, message); // Se lo notificamos al usuario (mensaje emergente)
} // onDeletedMessages()
/**
* Al producirse un error.
*/
#Override
public void onError(Context context, String errorId) {
Log.i(tag, "Error recibido: " + errorId);
displayMessage(context, getString(R.string.gcm_error, errorId)); // Lo mostramos por pantalla
} // onError()
/**
* Al producirse un error recuperable.
*/
#Override
protected boolean onRecoverableError(Context context, String errorId) {
Log.i(tag, "Recibido error recuperable: " + errorId);
displayMessage(context, getString(R.string.gcm_recoverable_error, errorId)); // Lo mostramos por pantalla
return super.onRecoverableError(context, errorId); // Devolvemos un booleano para saber como ha ido la cosa
} // onRecoverableError()
/**
* Genera una notificación para que el usuario sea informado de que ha recibido un mensaje.
*/
private static void generateNotification(Context context, String message) {
int icon = R.drawable.ic_launcher; // Icono que aparece en la barra de notificaciones (será el de la app desde donde creemos el objeto GGCM)
long when = System.currentTimeMillis(); // Instante en el que se produce la notificación
// Creamos la notificación:
NotificationManager notificationManager = (NotificationManager) context.getSystemService(Context.NOTIFICATION_SERVICE);
Notification notification = new Notification(icon, message, when);
String title = context.getString(R.string.app_name); // Título de la notificación (Nombre de la app)
// Gestionamos el Intent de la notificación:
Intent notificationIntent = new Intent(context, GGCM.NotificationActivity); // Lo configuramos para que empiece una nueva Actividad (NotificationActivity)
notificationIntent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP | Intent.FLAG_ACTIVITY_SINGLE_TOP);
PendingIntent intent = PendingIntent.getActivity(context, 0, notificationIntent, 0);
notification.setLatestEventInfo(context, title, message, intent);
notification.flags |= Notification.FLAG_AUTO_CANCEL;
notification.defaults |= Notification.DEFAULT_SOUND; // Sonido de notificación por defecto
// ¡¡¡ POR SI QUEREMOS USAR NUESTRO PROPIO SONIDO PERSONALIZADO !!!
//notification.sound = Uri.parse("android.resource://" + context.getPackageName() + "your_sound_file_name.mp3");
notification.defaults |= Notification.DEFAULT_VIBRATE; // Vibra (si la vibración está activa, claro)
notificationManager.notify(0, notification); // Notificamos (con todos los parámetros incluidos)
} // generateNotification()
} // GGCMIntentService
GGCM.java
package com.appacoustic.android.g.gcm;
...
/**
* #author AppAcoustiC <p>
* Engloba todo lo que conlleva el sistema Google Cloud Messaging.
*/
public class GGCM {
private final String tag = "GGCM";
private Context context;
// Variables que meteremos en la base de datos de nuestro Servidor particular:
static String name;
static String email;
static Class<?> NotificationActivity;
AsyncTask<Void, Void, Void> mRegisterTask; // Tarea de registro
AsyncTask<Void, Void, Void> mUnregisterTask; // Tarea de eliminación del registro
/**
* Constructor.
* #param context Contexto de la Actividad.
* #param SERVER_URL Base URL del Servidor (directorio raíz).
* #param SENDER_ID ID del proyecto en cuestión registrado para usar GCM.
* #param userName Nombre del usuario de la aplicación.
* #param cls Actividad que se inicia al pulsar las notificaciones recibidas.
*/
public GGCM(final Context context,
String SERVER_URL,
String SENDER_ID,
String userName,
Class<?> cls) {
// Primero de nada, comprobamos que está todo en orden para que el GCM funcione.
// Qué el dispositivo soporta GCM y que el Manifest está bien configurado. Esto, una vez testeado se puede comentar:
//checker(context);
// Comprobacion rutinaria de que tenemos inicializadas la variables que indican el Servidor y el ID del proyecto GCM:
G_A.checkNotNull(SERVER_URL, "SERVER_URL");
G_A.checkNotNull(SENDER_ID, "SENDER_ID");
// Asignamos los parámetros a las variables que usamos dentro del paquete:
this.context = context;
GCommonUtilities.SERVER_URL = SERVER_URL;
GCommonUtilities.SENDER_ID = SENDER_ID;
name = userName;
email = G_A.getEmailAdress(context);
NotificationActivity = cls;
// Comprobamos la conexión a internet:
GConnectionDetector gCD = new GConnectionDetector(context);
if (!gCD.isConnectingToInternet()) { // Si no hay internet
// Creamos nuestro Diálogo de alerta particular
GAlertDialog.showAlertDialog(context,
"Error de conexión a Internet",
"Por favor, conéctese para poder hacer uso de la aplicación.",
false);
return; // Paramos la ejecución del programa
}
context.registerReceiver(mHandleMessageReceiver, new IntentFilter(GCommonUtilities.DISPLAY_MESSAGE_ACTION)); // Registramos el receptor
} // GGCM()
/**
* Registra el dispositivo en el que está instalada la app.
*/
public void registerDevice() {
final String regId = GCMRegistrar.getRegistrationId(context); // Obtenemos el ID de registro
if (regId.equals("")) { // Si es "" es que aún no estamos registrados
GCMRegistrar.register(context, GCommonUtilities.SENDER_ID); // Nos registramos
Log.i(tag, "Nos acabamos de registrar en el GCM.");
} else {
// El dispositivo ya está registrado. Comprobamos el Servidor:
if (GCMRegistrar.isRegisteredOnServer(context)) {
// Nos saltamos el registro en el Servidor. Simplemente mostramos un mensaje por pantalla:
G_A.showToast(context, context.getString(R.string.already_registered), Toast.LENGTH_SHORT);
Log.i(tag, "Ya está registrado en nuestro Servidor.");
} else {
// Tratamos de registrarnos de nuevo. Hay que hacerlo mediante una Tarea Asíncrona:
mRegisterTask = new AsyncTask<Void, Void, Void>() {
#Override
protected Void doInBackground(Void... params) {
boolean registered = GServerUtilities.register(context, regId, name, email);
// Si llegados a este punto, todos los intentos de registrar el dispositivo a nuestro Servidor (Planet Devices) fallan,
// necesitaremos desregistrar el dispositivo desde GCM. La aplicación tratará de registrarse de nuevo cuando se reinicie.
// Hay que tener en cuenta que GCM enviará una devolución de llamada (callback) de borrado de registro al finalizar,
// pero GGCMIntentService.onUnregistered() lo ignorará:
if (!registered) {
GCMRegistrar.unregister(context); // Eliminamos el registro
}
return null;
} // doInBackground()
#Override
protected void onPostExecute(Void result) {
mRegisterTask = null; // Liberamos memoria
} // onPostExecute()
};
mRegisterTask.execute(null, null, null); // Ejecutamos la tarea
}
}
} // registerDevice()
/**
* Elimina el registro del dispositivo que tiene instalada la aplicación.
*/
public void unregisterDevice() {
final String regId = GCMRegistrar.getRegistrationId(context); // Obtenemos el ID de registro
//GServerUtilities.unregister(context, regId);
if (regId.equals("")) { // Si es "" es que aún no estamos registrados
Log.i(tag, "Nos estamos aún registrados. No se puede anular el registro.");
G_A.showToast(context, context.getString(R.string.already_unregistered), Toast.LENGTH_SHORT); // ESTO NO FUNCIONA COMO BEBERÍA !!!
} else {
// Tratamos de eliminar el registro. Hay que hacerlo mediante una Tarea Asíncrona:
mUnregisterTask = new AsyncTask<Void, Void, Void>() {
#Override
protected Void doInBackground(Void... params) {
GServerUtilities.unregister(context, regId); // Nos "desregistramos"
return null;
} // doInBackground()
#Override
protected void onPostExecute(Void result) {
mUnregisterTask = null; // Liberamos memoria
} // onPostExecute()
};
mUnregisterTask.execute(null, null, null); // Ejecutamos la tarea
}
} // unregisterDevice()
/**
* Comprobamos si el dispositivo soporta GCM y que el Manifest está bien configurado.
*/
private void checker(Context context) {
try {
GCMRegistrar.checkDevice(context);
Log.i(tag, "El dispositivo soporta GCM.");
GCMRegistrar.checkManifest(context);
Log.i(tag, "El Manifest está correctamente.");
} catch (UnsupportedOperationException e) {
Log.e(tag, "El dispositivo no soporta GCM.", e);
} catch (IllegalStateException e) {
Log.e(tag, "El Manifest no está bien configurado.", e);
}
} // checker()
/**
* Manejador para recibir mensajes.
*/
private final BroadcastReceiver mHandleMessageReceiver = new BroadcastReceiver() {
#Override
public void onReceive(Context context, Intent intent) {
String newMessage = intent.getExtras().getString(GCommonUtilities.EXTRA_MESSAGE); // Recogemos el mensaje
GWakeLocker.acquire(context); // Mantenemos el dispositivo a la espera de que acabe de procesar todo el mensaje (para que no entre en modo de suspensión)
// SI TENEMOS ESTO PUESTO MUESTRA TOAST CADA VEZ QUE ENVIAMOS UNA NOTIFICACIÓN PUSH !!!!!:
//G_A.showToast(context, newMessage, Toast.LENGTH_SHORT); // Lo mostramos por pantalla
GWakeLocker.release(); // Liberamos para ahorrar energía (importante para optimizar los recursos de la batería)
} // onReceive()
};
/**
* Realiza las acciones pertinentes cuando se hace un callback de onDestroy desde la Actividad que llama al objeto GGCM.
*/
public void setOnDestroy() {
if (mRegisterTask != null) {
mRegisterTask.cancel(true); // Cancelamos la Tarea de registro
}
context.unregisterReceiver(mHandleMessageReceiver); // Desregistramos el manejador de mensajes ?????????????????? ESTO CREO QUE HAY QUE QUITARLO, SINO NO LLEGARÁN LOS MENSAJES EMERGENTES
GCMRegistrar.onDestroy(context); // Destruimos
} // setOnDestroy()
} // GGCM
GCommonUtilities.java
package com.appacoustic.android.g.gcm;
import android.content.Context;
import android.content.Intent;
import android.util.Log;
/**
* #author AppAcoustiC <p>
* Utilidades comunes a todo el paquete. Las cargamos en el contructor de GGCM al hacer la llamada.
*/
public final class GCommonUtilities {
static String SERVER_URL; // Base URL del Servidor
static String SENDER_ID; // ID del proyecto en cuestión registrado para usar GCM
// Intentos usados para mostrar un mensaje en la pantalla:
static final String DISPLAY_MESSAGE_ACTION = "com.appacoustic.android.g.gcm.DISPLAY_MESSAGE"; // Nombre del paquete
static final String EXTRA_MESSAGE = "message"; // Extra
/**
* Notifica a la interfaz de usuario (UI) que tiene que mostrar un mensaje.<p>
* Este método está definido en el Helper común porque es usado por ambos: la interfaz de usuario y el Servicio.
* #param context Contexto de la actividad.
* #param message Mensaje a mostrar.
*/
static void displayMessage(Context context, String message) {
Intent intent = new Intent(DISPLAY_MESSAGE_ACTION); // Instanciamos el intento
intent.putExtra(EXTRA_MESSAGE, message); // Añadimos el mensaje que hemos metido como parámetro
context.sendBroadcast(intent); // Hace el envío asíncrono
} // displayMessage()
} // GCommonUtilities
GGCMBroadcastReceiver.java
package com.appacoustic.android.g.gcm;
import android.content.Context;
import android.content.Intent;
import android.util.Log;
import com.google.android.gcm.GCMBroadcastReceiver;
/**
* #author AppAcoustiC <p>
* Implementa el receptor de GCM.<p>
* De este modo irá al paquete donde tenemos nosotros nuestro GCMIntentService.
*/
public class GGCMBroadcastReceiver extends GCMBroadcastReceiver {
private final String tag = "GGCMBroadcastReceiver";
/**
* Devuelve el nombre de la clase donde tenemos implementado el servicio.
*/
#Override
protected String getGCMIntentServiceClassName(Context context) {
String s = GGCMIntentService.class.getName();
Log.d(tag, "Servicio: " + s);
return s;
} // getGCMIntentServiceClassName()
} // GGCMBroadcastReceiver
GServerUtilities.java
package com.appacoustic.android.g.gcm;
...
import com.appacoustic.android.g.R;
import com.google.android.gcm.GCMRegistrar;
/**
* #author AppAcoustiC <p>
* Utilidades de comunicación con nuestro Servidor (Planet Devices).
*/
public final class GServerUtilities {
private static final String TAG = "GServerUtilities";
private static final int MAX_ATTEMPTS = 5; // Nº máximo de intentos
private static final int BACKOFF_MILLI_SECONDS = 2000; // Tiempo para echarse atrás
private static final Random random = new Random(); // Objeto auxiliar para generar números aleatorios
/**
* Registra el dispositivo en nuestro Servidor.
* #param context Contexto de la Actividad.
* #param regId ID de registro.
* #param name Nombre del usuario.
* #param email Email del usuario.
* #return Si el registro ha sido correcto.
*/
static boolean register(final Context context, final String regId, String name, String email) {
Log.i(TAG, "Registrando dispositivo... (regId = " + regId + ")");
String serverUrl = SERVER_URL + "/register.php"; // Dirección donde tenemos el *.php que implementa el registro
// Parámetros:
Map<String, String> params = new HashMap<String, String>();
params.put("regId", regId); // ID de registro
params.put("name", name); // Nombre
params.put("email", email); // Email
long backoff = BACKOFF_MILLI_SECONDS + random.nextInt(1000); // Tiempo para echarse atrás (y un poco más cada vez)
// Una vez GCM devuelve el ID de registro, necesitamos registrar dicho ID en nuestro Servidor particular:
for (int i = 1; i <= MAX_ATTEMPTS; i++) { // Si el Servidor ha caído, lo volveremos a intentar alguna vez más
Log.d(TAG, "Intento de registro nº " + i + ".");
try {
displayMessage(context, context.getString(R.string.server_registering, i, MAX_ATTEMPTS)); // Mostramos por pantalla
post(serverUrl, params); // Hacemos el post con los parámetros hacia nuestro Servidor
GCMRegistrar.setRegisteredOnServer(context, true); // Indicamos que se registra
// Mostramos por pantalla que todo ha ido bien:
String message = context.getString(R.string.server_registered);
GCommonUtilities.displayMessage(context, message);
return true;
} catch (IOException e) {
// Aquí estamos simplificando el manejo de errores. En una aplicación real
// se debería de volver a procesar sólo los errores recuperables (como HTTP error code 503, e.g.):
Log.e(TAG, "Fallo tratando de registrarse. Nº de intento: " + i, e);
if (i == MAX_ATTEMPTS) {
break; // Si ya hemos gastado todos los intentos, paramos la aplicación
}
try {
Log.d(TAG, "Parando por " + backoff + " ms antes de volver a intentar.");
Thread.sleep(backoff); // Retardo
} catch (InterruptedException e1) {
Log.d(TAG, "Hilo interrumpido: Abortamos los restantes intentos.");
Thread.currentThread().interrupt(); // Actividad terminada antes de que la hayamos completado
return false;
}
backoff *= 2; // Incrementamos exponencialemente el tiempo de espera
}
}
// Si hemos llegado hasta aquí es porque hemos condumido todos los intentos.
// Mostramos que ha habido un error:
String message = context.getString(R.string.server_register_error, MAX_ATTEMPTS);
GCommonUtilities.displayMessage(context, message);
return false;
} // register()
/**
* Anula el registro del par "cuenta-dispositivo" en nuestro Servidor.
* #param context Contexto de la Actividad.
* #param regId ID de registro.
*/
static void unregister(final Context context, final String regId) {
Log.i(TAG, "Anulando el registro del dispositivo... (regId = " + regId + ")");
String serverUrl = SERVER_URL + "/unregister.php"; // Archivo *.php encargado de implementar el proceso
// Parámetros:
Map<String, String> params = new HashMap<String, String>();
params.put("regId", regId); // Sólo hace falta el ID de registro para eliminarlo
try {
post(serverUrl, params); // Hacemos el post con los parámetros hacia nuestro Servidor
GCMRegistrar.setRegisteredOnServer(context, false); // Indicamos que se desregistra
// Mostramos por pantalla que todo ha ido bien:
String message = context.getString(R.string.server_unregistered);
GCommonUtilities.displayMessage(context, message);
} catch (IOException e) {
// En este punto, el dispositivo está desregistrado de GCM, pero permanece registrado en nuestro Servidor de Planet Devices.
// Podríamos tratar de anular el registro de nuevo, pero no es necesario, ya que si el Servidor trata de enviar un mensaje al dispositivo,
// se generará un mensaje de error tipo "No registrado" y se debería de anular el registro del dispositivo.
// Mostramos que ha habido un error anulando el registro:
String message = context.getString(R.string.server_unregister_error, e.getMessage());
GCommonUtilities.displayMessage(context, message);
}
} // unregister()
/**
* Realiza un POST a nuestro Servidor.
* #param endpoint Dirección del POST.
* #param params Parámetros de la solicitud.
* #throws IOException
*/
private static void post(String endpoint, Map<String, String> params) throws IOException {
URL url; // Dirección del POST
try {
url = new URL(endpoint); // La inicializamos
} catch (MalformedURLException e) {
throw new IllegalArgumentException("URL incorrecta: " + endpoint); // La dirección no es correcta
}
// Creamos un StringBuilder para cargar el contenido del POST:
StringBuilder bodyBuilder = new StringBuilder();
Iterator<Entry<String, String>> iterator = params.entrySet().iterator();
// Construimos el cuerpo del POST usando los parámetros:
while (iterator.hasNext()) {
Entry<String, String> param = iterator.next();
bodyBuilder.append(param.getKey()).append('=').append(param.getValue());
if (iterator.hasNext()) {
bodyBuilder.append('&');
}
}
String body = bodyBuilder.toString(); // Pasamos a un único String todo el StringBuilder
Log.v(TAG, "Enviando '" + body + "' a " + url);
byte[] bytes = body.getBytes(); // Convertimos a bytes para que puedan viajar por la red mdiante un Stream
HttpURLConnection conn = null; // Conexión
try {
// Abrimos la conexión y la configuramos:
conn = (HttpURLConnection) url.openConnection();
conn.setDoOutput(true);
conn.setUseCaches(false);
conn.setFixedLengthStreamingMode(bytes.length);
conn.setRequestMethod("POST");
conn.setRequestProperty("Content-Type", "application/x-www-form-urlencoded;charset=UTF-8");
// Posteamos la solicitud:
OutputStream out = conn.getOutputStream(); // Instanciamos el flujo
out.write(bytes); // Enviamos los datos
out.close(); // Cerramos el Stream
// Manejamos la respuesta:
int status = conn.getResponseCode(); // Obtenemos el código de respuesta desde el Servidor (el 200 indica que todo ha ido bien)
if (status != 200) { // Si no es el código 200, es porque ha habido un error
throw new IOException("Envío fallido con error de código: " + status);
}
} finally {
if (conn != null) {
conn.disconnect(); // Al final desconectamos
}
}
} // post()
} // GServerUtilities
I have written an Android app which calls the library like that:
Call in onCreate()
// Creamos nuestro objeto GCM:
gGCM = new GGCM(context,
Att.SERVER_URL,
Att.SENDER_ID,
Att.userName,
NotificationActivity.class);
//gGCM.registerDevice(); // Nos registramos directamente
//gGCM.unregisterDevice();
I have a NotificationActivity which is the Activity which is thrown when you click the push notification and so on...
Finally my Manifest is here:
AndroidMainfest.xml
...
<uses-sdk
android:minSdkVersion="10"
android:targetSdkVersion="10" />
<uses-permission android:name="android.permission.INTERNET"/>
<!-- GCM requiere de una cuenta Google -->
<uses-permission android:name="android.permission.GET_ACCOUNTS" />
<!-- Se activa cuando se recibe un mensaje -->
<uses-permission android:name="android.permission.WAKE_LOCK" />
<!-- Crea un permiso específico para este paquete. Sólo esta app puede recibir estos mensajes -->
<permission
android:name="com.planetdevices.android.loyalty.permission.C2D_MESSAGE"
android:protectionLevel="signature" />
<uses-permission android:name="com.planetdevices.android.loyalty.permission.C2D_MESSAGE" />
<!-- Esta aplicación tiene permiso para registrarse y recibir mensajes de datos de Google -->
<uses-permission android:name="com.google.android.c2dm.permission.RECEIVE" />
<!-- Pemisos del estado de la red para detectar el status de Internet -->
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
<!-- Vibración -->
<uses-permission android:name="android.permission.VIBRATE" />
<application
android:allowBackup="true"
android:icon="#drawable/ic_launcher"
android:label="#string/app_name"
android:theme="#style/AppTheme" >
<activity
android:name="Splash"
android:label="#string/app_name"
android:screenOrientation="portrait"
android:theme="#style/Splash" >
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>
<activity android:name="MainActivity" android:screenOrientation="portrait"></activity>
<activity android:name="NotificationActivity" android:screenOrientation="portrait"></activity>
...
<!-- Receptor -->
<receiver
android:name="com.appacoustic.android.g.gcm.GGCMBroadcastReceiver"
android:permission="com.google.android.c2dm.permission.SEND" >
<intent-filter>
<action android:name="com.google.android.c2dm.intent.RECEIVE" />
<action android:name="com.google.android.c2dm.intent.REGISTRATION" />
<category android:name="com.appacoustic.android.g.gcm" />
</intent-filter>
</receiver>
<!-- Servicio -->
<service android:name="com.appacoustic.android.g.gcm.GGCMIntentService" />
</application>
</manifest>
Thank you so much for your help!
I’ve changed calling to SuperClass Constructor in GGCMIntentService. I have put directly the SENDER_ID as a String with its value. I have done it because when I stop the app, when that Constructor is called, throws a nullPointerException, because String “SENDER_ID” is not initialized.
public GGCMIntentService() {
//super(SENDER_ID); // Llamamos a la superclase
super("<<<ProjectNumber>>>"); // NEW WAY
} // GGCMIntentService()
After that, for a similar reason, I’ve put also directly Activity to start in the same Class in method generateNotification() like this:
Class<?> cls = null;
try {
cls = Class.forName("<<<packageName>>>.NotificationActivity");
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
I have put this instance a little lines below:
Intent notificationIntent = new Intent(context, cls);
It’s not the best solution, but it works perfectly whenever. :-)