Question

i’m trying to make a simple android apps that read live feed from a socialengine site
how can i do some actions:

• authenticate users
• read notifications
• read messages
• display updates

is there a special API i may use

sorry if the question is not clear

Answer 1

All the Activity feed data can be found in your database in the engine4_activity* tables. I’m afraid our support staff doesn’t have any diagrams or documents that can be shared at this time. Our staff doesn’t not usually provide customization assistance as that is beyond the scope of our support service (http://support.socialengine.com/questions/152/SocialEngine-Requirements). I will provide a brief descriptions of how to use the Authorization and Activity, however more detailed information would need to be inferred by reviewing SocialEngine’s code. As a note, while we don’t compile documentation for SocialEngine, our developers have used the PHPDocumentor style syntax through out our code and you can use an IDE like Neatbeans (http://netbeans.org/) to quickly access that information.

Authorization

SocialEngine has a few controller action helper classes that are used for query authorization within action controllers:

• application/modules/Authorization/Controller/Action/Helper/RequireAuth.php
• application/modules/Core/Controller/Action/Helper/RequireAbstract.php
• application/modules/Core/Controller/Action/Helper/RequireAdmin.php
• application/modules/Core/Controller/Action/Helper/RequireSubject.php
• application/modules/Core/Controller/Action/Helper/RequireUser.php

For the most part the only ones you’ll concern yourself with are these:

• application/modules/Authorization/Controller/Action/Helper/RequireAuth.php
• application/modules/Core/Controller/Action/Helper/RequireSubject.php
• application/modules/Core/Controller/Action/Helper/RequireUser.php

A good example of how these helpers are used can be found in the Album_AlbumController class:
application/modules/Album/controllers/AlbumController.php

public function init()
{
if( !$this->_helper->requireAuth()->setAuthParams('album', null, 'view')->isValid() ) return;

if( 0 !== ($photo_id = (int) $this->_getParam('photo_id')) &&
null !== ($photo = Engine_Api::_()->getItem('album_photo', $photo_id)) )
{
Engine_Api::_()->core()->setSubject($photo);
}

else if( 0 !== ($album_id = (int) $this->_getParam('album_id')) &&
null !== ($album = Engine_Api::_()->getItem('album', $album_id)) )
{
Engine_Api::_()->core()->setSubject($album);
}
}

public function editAction()
{
if( !$this->_helper->requireUser()->isValid() ) return;
if( !$this->_helper->requireSubject('album')->isValid() ) return;
if( !$this->_helper->requireAuth()->setAuthParams(null, null, 'edit')->isValid() ) return;

The code in the init function simply set’s the requirements for accessing the page, and then within the editAction function, checks are ran against the authorization data. The requireSubject and requireUser helpers are pretty straight forward:

1. requireSubject expects that subject for the page is set which in
   the above example gets done in the init function
2. requireUser checks to see if the viewer is a logged in user

The requireAuth helper is a little less straight forward. I’ll omit most of the abstract inner-workings for the sake of brevity. In the end, the helper points to the Authorization_Api_Core::isAllowed function:
application/modules/Authorization/Core/Api.php

/**
* Gets the specified permission for the context
*
* @param Core_Model_Item_Abstract|string $resource The resource type or object that is being accessed
* @param Core_Model_Item_Abstract $role The item (user) performing the action
* @param string $action The name of the action being performed
* @return mixed 0/1 for allowed, or data for settings
*/
public function isAllowed($resource, $role, $action = 'view')

The $resource and $role objects that the function expects are instances of Zend_Db_Table_Row which is termed Models within SocialEngine and are expected to be located in the Models directory of a module. When the isAllowed function is invoked, the authorization api will query the database against the engine4_authorization_allow, engine4_authorization_levels and engine4_authorization_permissions tables.

1. The engine4_authorization_levels table contains the member levels
   created by SocialEngine out of the box, as well as custom member
   levels created from the Manage > Member Levels section in the admin
   panel.
2. The engine4_authorization_permissions table contain all the
   default and admin specified permission handling, such as member
   level settings.
3. The engine4_authorization_allow contains the the permission data
   for individual objects. For example information about who is able to
   view a photo album would be placed there. Whether or not a
   engine4_authorization_allow.role_id (maps to item id for a model) is
   allowed to access the engine4_authorization_allow.resource_id (maps
   to item id for a model) is determined by the
   engine4_authorization_allow.value column which should contain a
   number 0-5.

application/modules/Authorization/Api/Core.php

class Authorization_Api_Core extends Core_Api_Abstract
{
/**
* Constants
*/
const LEVEL_DISALLOW = 0;
const LEVEL_ALLOW = 1;
const LEVEL_MODERATE = 2;
const LEVEL_NONBOOLEAN = 3;
const LEVEL_IGNORE = 4;
const LEVEL_SERIALIZED = 5;

0) Not allowed to access the linked resource. This is the same as the row not existing in the allow table

1) Allowed too access the linked resource

2) Allowed to access and moderate resources (ie. Superadmin, Admin and Moderator member level)

3-5) Get ignored as disallowed. These expect some custom logic in order to handle authorization appropriately.

Activity Feed

Posting to the activity feed is actually pretty simple. It’s more or less a single function call:

$api = Engine_Api::_()->getDbtable('actions', 'activity');
$api->addActivity($subject, $object, $action_type, $body, $params);

The first line in the above example uses SocialEngines Engine_Api class to load the Activity_Model_DbTable_Actions class (application/modules/Activity/Model/DbTable/Actions.php). The 2nd line is where the action is activity feed item is actually created.

1. $subject and $object should be an instances of
   Core_Model_Item_Abstract (a SocialEngine model).
2. $action_type is an action in the engine4_activity_actiontypes
   table

3. $body will be stored the engine4_activity_actions.body column in
   the database. This is the actual message for the activity. For
   example, when a use adds a new profile photo, the body column would
   be set to:

   {item:$subject} added a new profile photo

   When the activity content is assembled, {item:$subject} will be
   replaced with the user’s display name

4. $params will be serialized and stored in the
   engine4_activity_actions.params column. The data in the params
   column will passed on when assembling the activity description:

   application/modules/Activity/Model/Action.php

   class Activity_Model_Action extends Core_Model_Item_Abstract
   {
   ...
   public function getContent()
   {
   $model = Engine_Api::_()->getApi('core', 'activity');
   $params = array_merge(
   $this->toArray(),
   (array) $this->params,
   array(
   'subject' => $this->getSubject(),
   'object' => $this->getObject()
   )
   );
   //$content = $model->assemble($this->body, $params);
   $content = $model->assemble($this->getTypeInfo()->body, $params);
   return $content;
   }