pear channel-discover pear.pirum-project.org
pear install pirum/Pirum-beta

pirum build /var/www/pear

pirum add /var/www/pear package.tgz

pirum clone-package /var/www/pear http://pear.zfcampus.org/get/ZF-1.11.3.tgz

/**
 * Service Google C2dm
 * Implementation for Android Cloud to Device Messaging
 *
 * @category   Zend
 * @package    Zend_Service
 */
class Zend_Service_Google_C2dm
{
    /** 
     * @var string
     */
    const C2DM_SEND_URI = 'https://android.apis.google.com/c2dm/send';
 
    /** 
     * @var string
     */
    const AUTH_SERVICE_NAME = 'ac2dm';
 
    /** 
     * @var string
     */
    protected $_defaultPostUri = self::C2DM_SEND_URI;
 
    /** 
     * @var Zend_Http_Client
     */
    protected $_client;
 
    /** 
     * @var string
     */
    protected $_loginToken;
 
    /** 
     * @var array
     */
    protected $_options = array();
 
    /**
     * @var Zend_Service_Google_C2dm_Message
     */
    protected $_lastMessage;
 
    /**
     * @var Zend_Http_Response
     */
    protected $_lastResponse;
 
    /**
     * Constructor
     *
     * @param array|Zend_Config $options
     * @return Zend_Service_Google_C2dm
     */
    public function __construct($options=array())
    {
        $this->setOptions($options);
    }
 
    /**
     * Get Options for C2DM
     *
     * @return array
     */
    public function getOptions()
    {
        return $this->_options;
    }
 
    /**
     * Set Options for C2DM
     *
     * @param array|Zend_Config $options
     * @return Zend_Service_Google_C2dm
     * @throws Zend_Service_Google_C2dm_Exception
     */
    public function setOptions($options)
    {
        if ($options instanceof Zend_Config) {
            $options = $options->toArray();
        } elseif (!is_array($options)) {
            throw new Zend_Service_Google_C2dm_Exception('setOptions() expects either an array or a Zend_Config object');
        }
 
        foreach ($options as $key => $value) {
            $method = 'set' . ucfirst($key);
            if (method_exists($this, $method)) {
                $this->$method($value);
            } else {
                $this->_options[$k] = $v;
            }
        }
 
        return $this;
    }
 
    /**
     * Get Login Token
     *
     * @return string
     */
    public function getLoginToken()
    {
        return $this->_loginToken;
    }
    /**
     * Set Login Token
     *
     * @param string $token
     * @return Zend_Service_Google_C2dm
     * @throws Zend_Service_Google_C2dm_Exception
     */
    public function setLoginToken($token)
    {
        if (!is_string($token)) {
            throw new Zend_Service_Google_C2dm_Exception('setLoginToken() expects a string');
        }
        $this->_loginToken = $token;
        return $this;
    }
 
    /**
     * Get Http Client
     *
     * @return Zend_Http_Client
     */
    public function getHttpClient()
    {
        if (!$this->_client instanceof Zend_Http_Client) {
            $this->_client = new Zend_Http_Client();
            $this->_client->setConfig(array(
                'strictredirects' => true,
            ));
        }
        return $this->_client;
    }
 
    /**
     * Set Http Client
     *
     * @return Zend_Service_Google_C2dm
     */
    public function setHttpClient(Zend_Http_Client $client)
    {
        $this->_client = $client;
        return $this;
    }
 
    /**
     * Prepare an HTTP Request for C2DM
     *
     * @return void
     * @throws Zend_Service_Google_C2dm_Exception
     */
    protected function _prepareHttpRequest()
    {
        $client = $this->getHttpClient();
        $token = $this->getLoginToken();
        if (empty($token)) {
            throw new Zend_Service_Google_C2dm_Exception('Sending a message requires a Google Authorization Token');
        }
        $client->setUri($this->_defaultPostUri);
        $client->setHeaders('Authorization', 'GoogleLogin auth=' . $token);
        if (array_key_exists('delay_while_idle', $this->_options) && $this->_options['delay_while_idle']) {
            $client->setParameterPost('delay_while_idle', 1);
        }
        $this->_client = $client;
    }
 
    /**
     * Send a Message
     *
     * @param Zend_Service_Google_C2dm_Message $message
     * @return boolean
     * @throws Zend_Service_Google_C2dm_Exception
     */
    public function sendMessage(Zend_Service_Google_C2dm_Message $message)
    {
        $this->_lastMessage = $message;
        if (!$message->validate()) {
            throw new Zend_Service_Google_C2dm_Exception('sendMessage was unable to validate the message');
        }
        $this->_prepareHttpRequest();
        $client = $this->getHttpClient();
        $client->setParameterPost('registration_id', $message->getRegistrationId());
        $client->setParameterPost('collapse_key', $message->getCollapseKey());
        foreach ($message->getData() as $k => $v) {
            $client->setParameterPost('data.' . $k, $v);
        }
 
        $this->_lastResponse = $response= $client->request('POST');
 
        // check the response for errors:
        switch ($response->getStatus()) {
            case 503:
                throw new Zend_Service_Google_C2dm_Exception_ServerUnavailable('The server was unavailable, check Retry-After and try again');
                break;
            case 401:
                throw new Zend_Service_Google_C2dm_Exception_InvalidAuthToken('The Auth token: ' . $this->getLoginToken() . ' was invalid');
                break;
            default:
                // check response body for any errors.
                $body = $response->getBody();
                $body = preg_split('/=/', $body);
                if (!isset($body[0]) || !isset($body[1])) {
                    // bad response from google
                    throw new Zend_Service_Google_C2dm_Exception_ServerUnavailable('The server gave us an invalid response, we need to try again.');
                }
                if (strtolower($body[0]) == 'error') {
                    $exception = "Zend_Service_Google_C2dm_Exception_{$body[1]}";
                    throw new $exception();
                }
        }
        return true;
    }
 
    /**
     * Gets the Last Sent Message
     *
     * @return Zend_Service_Google_C2dm_Message
     */
    public function getLastMessage()
    {
        return $this->_lastMessage;
    }
 
    /**
     * Gets the Last Response
     *
     * @return Zend_Http_Response
     */
    public function getLastResponse()
    {
        return $this->_lastResponse;
    }
}

/**
 * C2dm Message
 * Implements an individual message to a client
 *
 * @category   Zend
 * @package    Zend_Service
 */
class Zend_Service_Google_C2dm_Message
{
 
    protected $_registrationId;
    protected $_collapseKey;
    protected $_data = array();
 
    /**
     * Constructor
     *
     * @param string $registrationId
     * @param string $collapseKey
     * @param array  $data
     * @return Zend_Service_Google_C2dm_Message
     */
    public function __construct($registrationId=null, $collapseKey=null, array $data=array())
    {
        $this->setRegistrationId($registrationId);
        $this->setCollapseKey($collapseKey);
        $this->setData($data);
    }
 
 
    /**
     * Get Registration ID
     *
     * @return string
     */
    public function getRegistrationId()
    {
        return $this->_registrationId;
    }
 
    /**
     * Set Registration ID
     *
     * @param string $registrationId
     * @return Zend_Service_Google_C2dm_Message
     * @throws Zend_Service_Google_C2dm_Exception
     */
    public function setRegistrationId($registrationId)
    {
        if (!is_string($registrationId)) {
            throw new Zend_Service_Google_C2dm_Exception('setRegistrationId() requires a string for registrationId');
        }
        $this->_registrationId = $registrationId;
        return $this;
    }
 
    /**
     * Get Collapse Key
     *
     * @return string
     */
    public function getCollapseKey()
    {
        return $this->_collapseKey;
    }
 
    /**
     * Get Collapse Key
     *
     * @return string
     */
    public function getCollapseKey()
    {
        return $this->_collapseKey;
    }
 
    /**
     * Set Collapse Key
     *
     * @param string $collapseKey
     * @return Zend_Service_Google_C2dm_Message
     * @throws Zend_Service_Google_C2dm_Exception
     */
    public function setCollapseKey($collapseKey)
    {
        if (!is_string($collapseKey)) {
            throw new Zend_Service_Google_C2dm_Exception('setCollapseKey() requires a string for collapseKey');
        }
        $this->_collapseKey = $collapseKey;
        return $this;
    }
 
    /**
     * Get Key Value Data Pairs
     *
     * @return array
     */
    public function getData()
    {
        return $this->_data;
    }
 
    /**
     * Set a Data Array
     *
     * @param array $data
     * @return Zend_Service_Google_C2dm_Message
     */
    public function setData(array $data)
    {
        $this->_data = $data;
    }
 
    /**
     * Validate the Message
     *
     * @return bool
     */
    public function validate()
    {
        if (empty($this->_registrationId)) {
            return false;
        } elseif (empty($this->_collapseKey)) {
            return false;
        } elseif (empty($this->_data)) {
            return false;
        }
        return true;
    }
}

/**
 * @category   Zend
 * @package    Zend_Service
 */
class Zend_Service_Google_C2dm_Exception extends Zend_Service_Exception
{}

/**
 * @category   Zend
 * @package    Zend_Service
 */
class Zend_Service_Google_C2dm_Exception_DeviceQuotaExceeded extends Zend_Service_Exception
{}

/**
 * @category   Zend
 * @package    Zend_Service
 */
class Zend_Service_Google_C2dm_Exception_InvalidRegistration extends Zend_Service_Exception
{}

/**
 * @category   Zend
 * @package    Zend_Service
 */
class Zend_Service_Google_C2dm_Exception_QuotaExceeded extends Zend_Service_Exception
{}

/**
 * @category   Zend
 * @package    Zend_Service
 */
class Zend_Service_Google_C2dm_Exception_InvalidAuthToken extends Zend_Service_Exception
{}

/**
 * @category   Zend
 * @package    Zend_Service
 */
class Zend_Service_Google_C2dm_Exception_MessageTooBig extends Zend_Service_Exception
{}

/**
 * @category   Zend
 * @package    Zend_Service
 */
class Zend_Service_Google_C2dm_Exception_NotRegistered extends Zend_Service_Exception
{}

/**
 * @category   Zend
 * @package    Zend_Service
 */
class Zend_Service_Google_C2dm_Exception_ServerUnavailable extends Zend_Service_Exception
{}

/**
 * C2DM Worker
 * Sends messages to Android devices through Cloud To Device Messaging
 */
class C2dmWorker extends Gearman_Worker
{
    /**
     * @var string
     */
    protected $_registerFunction = 'c2dm';
 
    /**
     * @var Zend_Service_Google_C2dm
     */
    protected $_c2dm;
 
    /**
     * Exponential Backoff / Retry-After
     *
     * @param int $fails
     * @param Zend_Http_Response
     * @return int
     */
    protected function getBackOffTime($fails, Zend_Http_Response $response)
    {
        if ($retry = $response->getHeader('Retry-After')) {
            if (is_string($retry)) {
                $retry = strtotime($retry) - time();
            }
            return (int) $retry;
        }
        return intval(pow(2, $fails) - 1);
    }
 
    /**
      * Initialize the Worker
      *
      * @return void
      */
    protected function init()
    {
        // attempt to login to google (should store this somewhere like sqlite for multiple workers
        try {
            $client = Zend_GData_ClientLogin::getHttpClient('YOUR_GOOGLE_ACCT_EMAIL', 'YOUR_GOOGLE_ACCT_PSWD', Zend_Service_Google_C2dm::AUTH_SERVICE_NAME, null, 'YOUR_GOOGLE_APP');
        } catch (Zend_Gdata_App_CaptchaRequiredException $cre) {
            // manual login is required
            echo 'URL of CAPTCHA image: ' . $cre->getCaptchaUrl() . PHP_EOL;
            echo 'Token ID: ' . $cre->getCaptchaToken() . PHP_EOL;
            exit(1);
        } catch (Zend_Gdata_App_AuthException $ae) {
            echo 'Problem authenticating: ' . $ae->exception() . PHP_EOL;
            exit(1);
        }
        $this->_c2dm = new Zend_Service_Google_C2dm();
        $this->_c2dm->setLoginToken($client->getClientLoginToken());
    }
 
    /**
     * Work
     *
     * @return void
     */
    protected function _work()
    {
        $workload = $this->getWorkload();
        // assume workload is json with registrationId, collapseKey and a data array
        $data = json_decode($workload);
        $message = new Zend_Service_Google_C2dm_Message(
            $data->registrationId,
            $data->collapseKey,
            $data->data
        );
        $failCount = 0;
        do {
            $tryAgain = false;  
            try {
                $this->_c2dm->sendMessage($message);
            } catch (Zend_Service_Google_C2dm_Exception_QuotaExceeded $e) {
                $failCount++;
                $tryAgain = true;
                usleep($this->_getBackOffTime($failCount, $c2dm->getLastResponse()) * 1000);
            } catch (Zend_Service_Google_C2dm_Exception_ServerUnavailable $e) {
                $failCount++;
                $tryAgain = true;
                usleep($this->_getBackOffTime($failCount, $c2dm->getLastResponse()) * 1000);
            } catch (Zend_Service_Google_C2dm_Exception_InvalidRegistration $e) {
                // do not attempt to send a message to this id again
            } catch (Zend_Service_Google_C2dm_Exception_NotRegistered $e) {
                // do not attempt to send a message to this id again
            } catch (Zend_Service_Google_C2dm_Exception_DeviceQuotaExceeded $e) {
                // you may attempt to retry, however, it may be best to let it go away
            } catch (Zend_Service_Google_C2dm_Exception_MessageTooBig $e) {
               // you may want to log this one and find the offending code and reduce the message size
            } catch (Zend_Service_Google_C2dm_Exception_MissingCollapseKey $e) {
               // you may want to log this one and find the offending code to ensure that this is pushed in
            } catch (Zend_Service_Google_C2dm_Exception $e) {
              // all of the rest of the exceptions are fatal in nature, log the exception and kill the client
              // sometimes we simply just need to generate a new id.
              exit(1);
            }
        } while ($tryAgain);
    }
}

<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.dummy.app" android:versionCode="1"
    android:versionName="1">
    <application android:icon="@drawable/icon" android:label="@string/app_name">
        <service android:name=".C2DMReceiver" />
        <receiver android:name="com.dummy.app.C2DMReceiver"
            android:permission="com.google.android.c2dm.permission.SEND">
            <intent -filter>
                <action android:name="com.google.android.c2dm.intent.RECEIVE" />
                <category android:name="com.dummy.app" />
            </intent>
            <intent -filter>
                <action android:name="com.google.android.c2dm.intent.REGISTRATION" />
                <category android:name="com.dummy.app" />
            </intent>
        </receiver>
    </application>
    <permission android:name="com.dummy.app.permission.C2D_MESSAGE"
        android:protectionLevel="signature" />
    <uses -permission android:name="com.dummy.app.permission.C2D_MESSAGE" />
    <uses -permission android:name="com.google.android.c2dm.permission.RECEIVE" />
</manifest>

 
package com.dummy.app;
 
import android.app.Notification;
import android.app.NotificationManager;
import android.app.PendingIntent;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.os.Bundle;
import android.util.Log;
 
import com.dummy.app.myIntent;
import com.dummy.app.R;
 
public class C2DMReceiver extends BroadcastReceiver {
    @Override
    public void onReceive(Context context, Intent intent) {
        if (intent.getAction().equals("com.google.android.c2dm.intent.REGISTRATION")) {
            String registration = intent.getStringExtra("registration_id");
            if (intent.getStringExtra("error") != null) {
                // handle an error for registration
            } else if (intent.getStringExtra("unregistered") != null) {
                // call service to handle unregistration
            } else if (registration != null) {
                // call service to handle registration
            }
        } else if (intent.getAction().equals("com.google.android.c2dm.intent.RECEIVE")) {
            // we are just going to say a few fields already exist here, but this is based
            // on what you may be sending from above in your data fields
            String title = intent.getExtras().getString("title");
            String message = intent.getExtras().getString("msg");
 
            Intent myIntent = new Intent(context, myIntent.class); // replace myIntent.class with your intent to launch
            PrendingIntent contentIntent = PendingIntent.getActivity(context, 0, myIntent, 0);
 
            // create the notification!
            int icon = R.drawable.icon;
            long when = System.currentTimeMillis();
            CharSequence contentTitle, contentMessage = null;
            contentTitle = (CharSequence) title;
 
            contentMessage = (CharSequence) message;
 
            NotificationManager nm = (NotificationManager) context.getSystemService(context.NOTIFICATION_SERVICE);
            Notification n = new Notification(icon, contentTitle, when);
            n.setLatestEventInfo(context, contentTitle, contentMessage, contentIntent);
            nm.notify(0, n); // 0 can be replaced with a number for separate style of messages
        }
    }
}

Intent registrationIntent = new Intent("com.google.android.c2dm.intent.REGISTER");
registrationIntent.putExtra("app", PendingIntent.getBroadcast(this, 0, new Intent(), 0)); // boilerplate
registrationIntent.putExtra("sender", emailOfSender);
startService(registrationIntent);