Net_Growl
[ class tree: Net_Growl ] [ index: Net_Growl ] [ all elements ]

Source for file Growl.php

Documentation is available at Growl.php

  1. <?php
  2. /**
  3.  * Copyright (c) 2009-2013, Laurent Laville <pear@laurent-laville.org>
  4.  *                          Bertrand Mansion <bmansion@mamasam.com>
  5.  *
  6.  * All rights reserved.
  7.  *
  8.  * Redistribution and use in source and binary forms, with or without
  9.  * modification, are permitted provided that the following conditions
  10.  * are met:
  11.  *
  12.  *     * Redistributions of source code must retain the above copyright
  13.  *       notice, this list of conditions and the following disclaimer.
  14.  *     * Redistributions in binary form must reproduce the above copyright
  15.  *       notice, this list of conditions and the following disclaimer in the
  16.  *       documentation and/or other materials provided with the distribution.
  17.  *     * Neither the name of the authors nor the names of its contributors
  18.  *       may be used to endorse or promote products derived from this software
  19.  *       without specific prior written permission.
  20.  *
  21.  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  22.  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  23.  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  24.  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
  25.  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  26.  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  27.  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  28.  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  29.  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  30.  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  31.  * POSSIBILITY OF SUCH DAMAGE.
  32.  *
  33.  * PHP version 5
  34.  *
  35.  * @category Networking
  36.  * @package  Net_Growl
  37.  * @author   Laurent Laville <pear@laurent-laville.org>
  38.  * @author   Bertrand Mansion <bmansion@mamasam.com>
  39.  * @license  http://www.opensource.org/licenses/bsd-license.php  BSD
  40.  * @version  SVN: $Id: Growl.php 329346 2013-01-29 17:07:45Z farell $
  41.  * @link     http://growl.laurent-laville.org/
  42.  * @link     http://pear.php.net/package/Net_Growl
  43.  * @since    File available since Release 0.9.0
  44.  */
  45.  
  46. /**
  47.  * Sends notifications to {@link http://growl.info Growl}
  48.  *
  49.  * This package makes it possible to easily send a notification from
  50.  * your PHP script to {@link http://growl.info Growl}.
  51.  *
  52.  * Growl is a global notification system for Mac OS X.
  53.  * Any application can send a notification to Growl, which will display
  54.  * an attractive message on your screen. Growl currently works with a
  55.  * growing number of applications.
  56.  *
  57.  * The class provides the following capabilities:
  58.  * - Register your PHP application in Growl.
  59.  * - Let Growl know what kind of notifications to expect.
  60.  * - Notify Growl.
  61.  * - Set a maximum number of notifications to be displayed (beware the loops !).
  62.  *
  63.  * @category Networking
  64.  * @package  Net_Growl
  65.  * @author   Laurent Laville <pear@laurent-laville.org>
  66.  * @author   Bertrand Mansion <bmansion@mamasam.com>
  67.  * @license  http://www.opensource.org/licenses/bsd-license.php  BSD
  68.  * @version  Release: 2.7.0
  69.  * @link     http://growl.laurent-laville.org/
  70.  * @link     http://pear.php.net/package/Net_Growl
  71.  * @link     http://growl.info Growl Homepage
  72.  * @since    Class available since Release 0.9.0
  73.  */
  74. class Net_Growl
  75. {
  76.     /**
  77.      * Growl version
  78.      */
  79.     const VERSION = '2.7.0';
  80.  
  81.     /**
  82.      * Growl default UDP port
  83.      */
  84.     const UDP_PORT = 9887;
  85.  
  86.     /**
  87.      * Growl default GNTP port
  88.      */
  89.     const GNTP_PORT = 23053;
  90.  
  91.     /**
  92.      * Growl priorities
  93.      */
  94.     const PRIORITY_LOW = -2;
  95.     const PRIORITY_MODERATE = -1;
  96.     const PRIORITY_NORMAL = 0;
  97.     const PRIORITY_HIGH = 1;
  98.     const PRIORITY_EMERGENCY = 2;
  99.  
  100.     /**
  101.      * PHP application object
  102.      *
  103.      * This is usually a Net_Growl_Application object but can really be
  104.      * any other object as long as Net_Growl_Application methods are
  105.      * implemented.
  106.      *
  107.      * @var object 
  108.      */
  109.     private $_application;
  110.  
  111.     /**
  112.      * Application is registered
  113.      * @var bool 
  114.      */
  115.     protected $isRegistered = false;
  116.  
  117.     /**
  118.      * Net_Growl connection options
  119.      * @var array 
  120.      */
  121.     protected $options = array(
  122.         'host' => '127.0.0.1',
  123.         'port' => self::UDP_PORT,
  124.         'protocol' => 'udp',
  125.         'timeout' => 30,
  126.         'context' => array(),
  127.         'passwordHashAlgorithm' => 'MD5',
  128.         'encryptionAlgorithm' => 'NONE',
  129.         'debug' => false,
  130.         'resourceDir' => false,
  131.         'defaultIcon' => 'growl.png'
  132.     );
  133.  
  134.     /**
  135.      * Current number of notification being displayed on user desktop
  136.      * @var int 
  137.      */
  138.     protected $growlNotificationCount = 0;
  139.  
  140.     /**
  141.      * Maximum number of notification to be displayed on user desktop
  142.      * @var int 
  143.      */
  144.     private $_growlNotificationLimit = 0;
  145.  
  146.     /**
  147.      * Handle to the log file.
  148.      * @var resource 
  149.      * @since 2.0.0b2
  150.      */
  151.     private $_fp = false;
  152.  
  153.     /**
  154.      * Notification callback results
  155.      *
  156.      * @var array 
  157.      * @since 2.0.0b2
  158.      */
  159.     protected $growlNotificationCallback = array();
  160.  
  161.     /**
  162.      * Notification unique instance
  163.      * @var   object 
  164.      * @since 2.1.0
  165.      * @see   singleton, reset
  166.      */
  167.     protected static $instance = null;
  168.  
  169.     /**
  170.      * Singleton
  171.      *
  172.      * Makes sure there is only one Growl connection open.
  173.      *
  174.      * @param mixed  &$application  Can be either a Net_Growl_Application object
  175.      *                               or the application name string
  176.      * @param array  $notifications List of notification types
  177.      * @param string $password      (optional) Password for Growl
  178.      * @param array  $options       (optional) List of options : 'host', 'port',
  179.      *                               'protocol', 'timeout' for Growl socket server.
  180.      *                               'passwordHashAlgorithm', 'encryptionAlgorithm'
  181.      *                               to secure communications.
  182.      *                               'debug' to know what data are sent and received.
  183.      *
  184.      * @return object Net_Growl 
  185.      * @throws Net_Growl_Exception if class handler does not exists
  186.      */
  187.     public static final function singleton(&$application$notifications,
  188.         $password ''$options = array()
  189.     {
  190.         if (isset($options['errorHandler']&& $options['errorHandler'=== true{
  191.             // Converts standard error into exception
  192.             set_error_handler(array('Net_Growl''errorHandler'));
  193.         }
  194.  
  195.         if (self::$instance === null{
  196.             if (isset($options['protocol'])) {
  197.                 if ($options['protocol'== 'tcp'{
  198.                     $protocol 'gntp';
  199.                 else {
  200.                     $protocol $options['protocol'];
  201.                 }
  202.             else {
  203.                 $protocol 'udp';
  204.             }
  205.             if ($protocol == 'udp'{
  206.                 $options['port'= self::UDP_PORT;
  207.             else {
  208.                 $options['port'= self::GNTP_PORT;
  209.             }
  210.             $class 'Net_Growl_' ucfirst($protocol);
  211.  
  212.             if (class_exists($classtrue)) {
  213.                 self::$instance = new $class(
  214.                     $application$notifications$password$options
  215.                 );
  216.             else {
  217.                 $message 'Cannot find class "'.$class.'"';
  218.                 throw new Net_Growl_Exception($message);
  219.             }
  220.         }
  221.         return self::$instance;
  222.     }
  223.  
  224.     /**
  225.      * Resettable Singleton Solution
  226.      *
  227.      * @return void 
  228.      * @link http://sebastian-bergmann.de/archives/882-guid.html
  229.      *        Testing Code That Uses Singletons
  230.      * @since 2.1.0
  231.      */
  232.     public static final function reset()
  233.     {
  234.         self::$instance = null;
  235.     }
  236.  
  237.     /**
  238.      * Constructor
  239.      *
  240.      * This method instantiate a new Net_Growl object and opens a socket connection
  241.      * to the specified Growl socket server.
  242.      * Currently, only UDP is supported by Growl.
  243.      * The constructor registers a shutdown function {@link Net_Growl::_Net_Growl()}
  244.      * that closes the socket if it is open.
  245.      *
  246.      * Example 1.
  247.      * <code>
  248.      * require_once 'Net/Growl.php';
  249.      *
  250.      * $notifications = array('Errors', 'Messages');
  251.      * $growl = Net_Growl::singleton('My application', $notification);
  252.      * $growl->notify( 'Messages',
  253.      *                 'My notification title',
  254.      *                 'My notification description');
  255.      * </code>
  256.      *
  257.      * @param mixed  &$application  Can be either a Net_Growl_Application object
  258.      *                               or the application name string
  259.      * @param array  $notifications (optional) List of notification types
  260.      * @param string $password      (optional) Password for Growl
  261.      * @param array  $options       (optional) List of options : 'host', 'port',
  262.      *                               'protocol', 'timeout' for Growl socket server.
  263.      *                               'passwordHashAlgorithm', 'encryptionAlgorithm'
  264.      *                               to secure communications.
  265.      *                               'debug' to know what data are sent and received.
  266.      *
  267.      * @return void 
  268.      */
  269.     protected function __construct(&$application$notifications = array(),
  270.         $password ''$options = array()
  271.     {
  272.         foreach ($options as $k => $v{
  273.             if (isset($this->options[$k])) {
  274.                 $this->options[$k$v;
  275.             }
  276.         }
  277.         $timeout $this->options['timeout'];
  278.         if (!is_int($timeout)) {
  279.             // get default timeout (in seconds) for socket based streams.
  280.             $timeout ini_get('default_socket_timeout');
  281.         }
  282.         if (!is_int($timeout)) {
  283.             // if default timeout not available on php.ini, then use this one
  284.             $timeout = 30;
  285.         }
  286.         $this->options['timeout'$timeout;
  287.  
  288.         if (is_string($application)) {
  289.             if (isset($options['AppIcon'])) {
  290.                 $icon $options['AppIcon'];
  291.             else {
  292.                 $icon '';
  293.             }
  294.             $this->_application = new Net_Growl_Application(
  295.                 $application$notifications$password$icon
  296.             );
  297.         elseif (is_object($application)) {
  298.             $this->_application $application;
  299.         }
  300.  
  301.         if (is_string($this->options['debug'])) {
  302.             $this->_fp fopen($this->options['debug']'a');
  303.         }
  304.     }
  305.  
  306.     /**
  307.      * Destructor
  308.      *
  309.      * @since 2.0.0b2
  310.      */
  311.     public function __destruct()
  312.     {
  313.         if (is_resource($this->_fp)) {
  314.             fclose($this->_fp);
  315.         }
  316.     }
  317.  
  318.     /**
  319.      * Gets options used with current Growl object
  320.      *
  321.      * @return array 
  322.      * @since  2.6.0
  323.      */
  324.     public function getOptions()
  325.     {
  326.         return $this->options;
  327.     }
  328.  
  329.     /**
  330.      * Limit the number of notifications
  331.      *
  332.      * This method limits the number of notifications to be displayed on
  333.      * the Growl user desktop. By default, there is no limit. It is used
  334.      * mostly to prevent problem with notifications within loops.
  335.      *
  336.      * @param int $max Maximum number of notifications
  337.      *
  338.      * @return void 
  339.      */
  340.     public function setNotificationLimit($max)
  341.     {
  342.         $this->_growlNotificationLimit $max;
  343.     }
  344.  
  345.     /**
  346.      * Returns the registered application object
  347.      *
  348.      * @return object Application 
  349.      * @see Net_Growl_Application
  350.      */
  351.     public function getApplication()
  352.     {
  353.         return $this->_application;
  354.     }
  355.  
  356.     /**
  357.      * Sends a application register to Growl
  358.      *
  359.      * @return Net_Growl_Response 
  360.      * @throws Net_Growl_Exception if REGISTER failed
  361.      */
  362.     public function register()
  363.     {
  364.         return $this->sendRegister();
  365.     }
  366.  
  367.     /**
  368.      * Sends a notification to Growl
  369.      *
  370.      * Growl notifications have a name, a title, a description and
  371.      * a few options, depending on the kind of display plugin you use.
  372.      * The bubble plugin is recommended, until there is a plugin more
  373.      * appropriate for these kind of notifications.
  374.      *
  375.      * The current options supported by most Growl plugins are:
  376.      * <pre>
  377.      * array('priority' => 0, 'sticky' => false)
  378.      * </pre>
  379.      * - sticky: whether the bubble stays on screen until the user clicks on it.
  380.      * - priority: a number from -2 (low) to 2 (high), default is 0 (normal).
  381.      *
  382.      * @param string $name        Notification name
  383.      * @param string $title       Notification title
  384.      * @param string $description (optional) Notification description
  385.      * @param string $options     (optional) few Notification options
  386.      *
  387.      * @return Net_Growl_Response | FALSE
  388.      * @throws Net_Growl_Exception if NOTIFY failed
  389.      */
  390.     public function notify($name$title$description ''$options = array())
  391.     {
  392.         if ($this->_growlNotificationLimit > 0
  393.             && $this->growlNotificationCount >= $this->_growlNotificationLimit
  394.         {
  395.             // limit reached: no more notification displayed on user desktop
  396.             return false;
  397.         }
  398.  
  399.         if (!$this->isRegistered{
  400.             $this->sendRegister();
  401.         }
  402.         return $this->sendNotify($name$title$description$options);
  403.     }
  404.  
  405.     /**
  406.      * Alias of notify() method.
  407.      *
  408.      * @param string $name        Notification name
  409.      * @param string $title       Notification title
  410.      * @param string $description (optional) Notification description
  411.      * @param string $options     (optional) few Notification options
  412.      *
  413.      * @return Net_Growl_Response | FALSE
  414.      * @throws Net_Growl_Exception if NOTIFY failed
  415.      */
  416.     public function publish($name$title$description ''$options = array())
  417.     {
  418.         return $this->notify($name$title$description$options);
  419.     }
  420.  
  421.     /**
  422.      * Send request to remote server
  423.      *
  424.      * @param string $method   Either REGISTER, NOTIFY
  425.      * @param mixed  $data     Data block to send
  426.      * @param bool   $callback (optional) Socket callback request
  427.      *
  428.      * @return Net_Growl_Response | TRUE
  429.      * @throws Net_Growl_Exception if remote server communication failure
  430.      */
  431.     protected function sendRequest($method$data$callback = false)
  432.     {
  433.         // @codeCoverageIgnoreStart
  434.         $protocol $this->options['protocol'== 'udp' 'udp' 'tcp';
  435.  
  436.         $addr $protocol '://' $this->options['host'];
  437.  
  438.         $this->debug(
  439.             $addr ':' .
  440.             $this->options['port'' ' .
  441.             $this->options['timeout']
  442.         );
  443.  
  444.         // open connection
  445.         if (is_array($this->options['context'])
  446.             && function_exists('stream_context_create')
  447.         {
  448.             $context stream_context_create($this->options['context']);
  449.  
  450.             if (function_exists('stream_socket_client')) {
  451.                 $flags = STREAM_CLIENT_CONNECT;
  452.                 $addr  $addr ':' $this->options['port'];
  453.                 $sh @stream_socket_client(
  454.                     $addr$errno$errstr,
  455.                     $this->options['timeout']$flags$context
  456.                 );
  457.             else {
  458.                 $sh @fsockopen(
  459.                     $addr$this->options['port'],
  460.                     $errno$errstr$$this->options['timeout']$context
  461.                 );
  462.             }
  463.         else {
  464.             $sh @fsockopen(
  465.                 $addr$this->options['port'],
  466.                 $errno$errstr$$this->options['timeout']
  467.             );
  468.         }
  469.  
  470.         if ($sh === false{
  471.             $this->debug($errstr'error');
  472.             $error 'Could not connect to Growl Server.';
  473.             throw new Net_Growl_Exception($error);
  474.         }
  475.         stream_set_timeout($sh$this->options['timeout']0);
  476.  
  477.         $this->debug($data);
  478.         $res fwrite($sh$data$this->strByteLen($data));
  479.  
  480.         if ($res === false{
  481.             $error 'Could not send data to Growl Server.';
  482.             throw new Net_Growl_Exception($error);
  483.         }
  484.  
  485.         switch ($protocol{
  486.         case 'tcp':
  487.             // read GNTP response
  488.             $line $this->_readLine($sh);
  489.             $this->debug($line);
  490.             $response = new Net_Growl_Response($line);
  491.             $statusOK ($response->getStatus(== 'OK');
  492.             while ($this->strByteLen($line> 0{
  493.                 $line $this->_readLine($sh);
  494.                 $response->appendBody($line."\r\n");
  495.                 if (is_resource($this->_fp)) {
  496.                     $this->debug($line);
  497.                 }
  498.             }
  499.  
  500.             if ($statusOK
  501.                 && $callback === true
  502.                 && $method == 'NOTIFY'
  503.             {
  504.                 // read GNTP socket Callback response
  505.                 $line $this->_readLine($sh);
  506.                 $this->debug($line);
  507.                 if (preg_match('/^GNTP\/1.0 -(\w+).*$/'$line$resp)) {
  508.                     $res ($resp[1== 'CALLBACK');
  509.                     if ($res{
  510.                         while ($this->strByteLen($line> 0{
  511.                             $line $this->_readLine($sh);
  512.                             $this->debug($line);
  513.                             $eon = true;
  514.  
  515.                             $nid preg_match(
  516.                                 '/^Notification-ID: (.*)$/',
  517.                                 $line$resp
  518.                             );
  519.                             if ($nid{
  520.                                 $eon = false;
  521.                             }
  522.  
  523.                             $ncr preg_match(
  524.                                 '/^Notification-Callback-Result: (.*)$/',
  525.                                 $line$resp
  526.                             );
  527.                             if ($ncr{
  528.                                 $this->growlNotificationCallback[$resp[1];
  529.                                 $eon = false;
  530.                             }
  531.  
  532.                             $ncc preg_match(
  533.                                 '/^Notification-Callback-Context: (.*)$/',
  534.                                 $line$resp
  535.                             );
  536.                             if ($ncc{
  537.                                 $this->growlNotificationCallback[$resp[1];
  538.                                 $eon = false;
  539.                             }
  540.  
  541.                             $ncct preg_match(
  542.                                 '/^Notification-Callback-Context-Type: (.*)$/',
  543.                                 $line$resp
  544.                             );
  545.                             if ($ncct{
  546.                                 $this->growlNotificationCallback[$resp[1];
  547.                                 $eon = false;
  548.                             }
  549.  
  550.                             $nct preg_match(
  551.                                 '/^Notification-Callback-Timestamp: (.*)$/',
  552.                                 $line$resp
  553.                             );
  554.                             if ($nct{
  555.                                 $this->growlNotificationCallback[$resp[1];
  556.                                 $eon = false;
  557.                             }
  558.  
  559.                             if ($eon{
  560.                                 break;
  561.                             }
  562.                         }
  563.                     }
  564.                 }
  565.  
  566.                 if (is_resource($this->_fp)) {
  567.                     while ($this->strByteLen($line> 0{
  568.                         $line $this->_readLine($sh);
  569.                         $this->debug($line);
  570.                     }
  571.                 }
  572.             }
  573.             break;
  574.         case 'udp':
  575.             $statusOK $response = true;
  576.             break;
  577.         }
  578.  
  579.         switch (strtoupper($method)) {
  580.         case 'REGISTER':
  581.             if ($statusOK{
  582.                 $this->isRegistered = true;
  583.             }
  584.             break;
  585.         case 'NOTIFY':
  586.             if ($statusOK{
  587.                 $this->growlNotificationCount++;
  588.             }
  589.             break;
  590.         }
  591.  
  592.         // close connection
  593.         fclose($sh);
  594.  
  595.         return $response;
  596.         // @codeCoverageIgnoreEnd
  597.     }
  598.  
  599.     /**
  600.      * Returns Growl default icon logo binary data
  601.      *
  602.      * @return string 
  603.      * @throws Net_Growl_Exception if cannot get icon resource contents
  604.      */
  605.     public function getDefaultGrowlIcon()
  606.     {
  607.         if (isset($this->options['resourceDir'])
  608.             && is_dir($this->options['resourceDir'])
  609.         {
  610.             $resourceDir $this->options['resourceDir'];
  611.         else {
  612.             $resourceDir '@data_dir@' . DIRECTORY_SEPARATOR .
  613.                 'Net_Growl' . DIRECTORY_SEPARATOR . 'data';
  614.         }
  615.  
  616.         $icon = new Net_Growl_Icon(
  617.             $resourceDir . DIRECTORY_SEPARATOR . $this->options['defaultIcon']
  618.         );
  619.         $data $icon->getContents();
  620.         if (empty($data)) {
  621.             throw new Net_Growl_Exception('Invalid Icon Resource');
  622.         }
  623.         return $data;
  624.     }
  625.  
  626.     /**
  627.      * Logs GNTP IN/OUT messages
  628.      *
  629.      * @param string $message  String containing the message to log
  630.      * @param string $priority (optional) String containing a priority name
  631.      *
  632.      * @return void 
  633.      */
  634.     protected function debug($message$priority 'debug')
  635.     {
  636.         if (is_resource($this->_fp)
  637.             && $this->strByteLen($message> 0
  638.         {
  639.             fwrite(
  640.                 $this->_fp,
  641.                 date("Y-m-d H:i:s". " [$priority] - " . $message "\n"
  642.             );
  643.         }
  644.     }
  645.  
  646.     /**
  647.      * Converts standard error into exception
  648.      *
  649.      * @param int    $errno   contains the level of the error raised
  650.      * @param string $errstr  contains the error message
  651.      * @param string $errfile contains the filename that the error was raised in
  652.      * @param int    $errline contains the line number the error was raised at
  653.      *
  654.      * @return void 
  655.      * @throws ErrorException when a standard error occured with severity level
  656.      *                         we are asking for (uses error_reporting)
  657.      * @since 2.1.0
  658.      */
  659.     public static function errorHandler($errno$errstr$errfile$errline)
  660.     {
  661.         // Only catch errors we are asking for
  662.         if ((error_reporting($errno== 0{
  663.             return;
  664.         }
  665.         throw new ErrorException($errstr0$errno$errfile$errline);
  666.     }
  667.  
  668.     /**
  669.      * Read until either the end of the socket or a newline, whichever
  670.      * comes first. Strips the trailing newline from the returned data.
  671.      *
  672.      * @param mixed $fp a file pointer resource
  673.      *
  674.      * @return All available data up to a newline, without that
  675.      *          newline, or until the end of the socket,
  676.      * @throws Net_Growl_Exception if not connected
  677.      */
  678.     private function _readLine($fp)
  679.     {
  680.         // @codeCoverageIgnoreStart
  681.         if (!is_resource($fp)) {
  682.             throw new Net_Growl_Exception('not connected');
  683.         }
  684.  
  685.         $line '';
  686.         $timeout time($this->options['timeout'];
  687.         while (!feof($fp&& (time($timeout)) {
  688.             $line .= @fgets($fp);
  689.             if (mb_substr($line-1== "\n" && $this->strByteLen($line> 0{
  690.                 break;
  691.             }
  692.         }
  693.         return rtrim($line"\r\n");
  694.         // @codeCoverageIgnoreEnd
  695.     }
  696.  
  697.     /**
  698.      * Encodes a detect_order string to UTF-8
  699.      *
  700.      * @param string $data an intended string.
  701.      *
  702.      * @return Returns of the UTF-8 translation of $data.
  703.      *
  704.      * @see http://www.php.net/manual/en/function.mb-detect-encoding.php
  705.      * @see http://www.php.net/manual/en/function.mb-convert-encoding.php
  706.      */
  707.     protected function utf8Encode($data)
  708.     {
  709.         if (extension_loaded('mbstring')) {
  710.             return mb_convert_encoding($data'UTF-8''auto');
  711.         else {
  712.             return utf8_encode($data);
  713.         }
  714.     }
  715.  
  716.     /**
  717.      * Get string byte length
  718.      *
  719.      * @param string $string The string being measured for byte length.
  720.      *
  721.      * @return The byte length of the $string.
  722.      */
  723.     protected function strByteLen($string)
  724.     {
  725.         return strlen(bin2hex($string)) / 2;
  726.     }
  727.  
  728. }

Documentation generated on Tue, 29 Jan 2013 18:30:05 +0000 by phpDocumentor 1.4.3. PEAR Logo Copyright © PHP Group 2004.