Beispiel #1
0
void BlackBerryMessenger::HandleEvent(bps_event_t* event)
{
    int event_category = 0;
    int event_type = 0;
    bbmsp_event_t* bbmsp_event = 0;

    // Retrieve the bbmsp event category, type, and actual event
    bbmsp_event_get_category( event, &event_category );
    bbmsp_event_get_type( event, &event_type );
    bbmsp_event_get( event, &bbmsp_event );

    // Determine the bbmsp event type & handle accordingly
    // In this case only BBMSP_SP_EVENT_ACCESS_CHANGED
    // events are handled, which are triggered when
    // the init is complete and we're ready to register and when
    // the registration status of the app changes

    if( event_type == BBMSP_SP_EVENT_ACCESS_CHANGED )
    {
        // Determine if the app has successfully
        // registered and handle each case
        int event_is_access_allowed = bbmsp_event_access_changed_get_access_allowed( bbmsp_event );
        if( event_is_access_allowed == 1 )
        {
            // Registration successful, The bbmsp APIs are ready to use
            m_State = BBMState_Ready;
        }
        else
        {
            bbmsp_access_error_codes_t event_access_error_code;// = 0;
            event_access_error_code = bbmsp_event_access_changed_get_access_error_code( bbmsp_event );

            if( event_access_error_code == BBMSP_ACCESS_UNREGISTERED )
            {
                Register();
            }
            else if( event_access_error_code != BBMSP_ACCESS_PENDING &&
                     event_access_error_code != BBMSP_ACCESS_ALLOWED )
            {
                m_State = BBMState_Failed;
            }
        }
    }
    else
    {
        if( m_State == BBMState_Ready )
        {
            // Handle other events now that the
            // bbmsp APIs are ready to use
        }
    }
}
int BBMBPS::WaitForEvents()
{
    MUTEX_LOCK();
    int status = bbmsp_request_events(0);

    bps_event_t *event = NULL;
    bbmsp_event_t *bbmEvent;
    bbmsp_profile_t *bbmProfile;

    for (;;) {
        MUTEX_UNLOCK();
        bps_get_event(&event, -1);
        MUTEX_LOCK();
        if (event) {
            int event_domain = bps_event_get_domain(event);

            if (event_domain == bbmsp_get_domain()) {
                int eventCategory = 0;
                int eventType = 0;

                bbmsp_event_get(event, &bbmEvent);

                if (bbmsp_event_get_category(event, &eventCategory) == BBMSP_SUCCESS) {
                    switch (eventCategory) {
                        case BBMSP_REGISTRATION:
                        {
                            if (bbmsp_event_get_type(event, &eventType) == BBMSP_SUCCESS) {
                                switch (eventType) {
                                    case BBMSP_SP_EVENT_ACCESS_CHANGED:
                                        processAccessCode(bbmsp_event_access_changed_get_access_error_code(bbmEvent));
                                        break;
                                }
                            }
                            break;
                        }
                        case BBMSP_USER_PROFILE:
                        {
                            if (bbmsp_event_get_type(event, &eventType) == BBMSP_SUCCESS) {
                                switch (eventType) {
                                    case BBMSP_SP_EVENT_PROFILE_CHANGED:
                                    {
                                        bbmsp_presence_update_types_t profileUpdateType;
                                        bbmsp_event_profile_changed_get_profile(bbmEvent, &bbmProfile);
                                        if (bbmsp_event_profile_changed_get_presence_update_type(bbmEvent, &profileUpdateType) == BBMSP_SUCCESS) {
                                            if (profileUpdateType == BBMSP_DISPLAY_PICTURE) {
                                                bbmsp_image_t *avatar;
                                                char *imgData = NULL;
                                                char *output = NULL;

                                                bbmsp_image_create_empty(&avatar);
                                                if (bbmsp_profile_get_display_picture(bbmProfile, avatar) == BBMSP_SUCCESS) {
                                                    imgData = bbmsp_image_get_data(avatar);

                                                    int size = bbmsp_image_get_data_size(avatar);
                                                    output = new char[size*4];

                                                    int bufferSize = b64_ntop(reinterpret_cast<unsigned char *>(imgData), bbmsp_image_get_data_size(avatar), output, size*4);
                                                    output[bufferSize] = 0;
                                                    m_pParent->NotifyEvent(std::string("self.getDisplayPicture ").append(output));
                                                    delete output;
                                                }
                                                bbmsp_image_destroy(&avatar);
                                            } else {
                                                processProfileUpdate(bbmEvent);
                                            }
                                        }
                                        break;
                                    }
                                }
                            }
                            break;
                        }
                        case BBMSP_CONTACT_LIST:
                        {
                            if (bbmsp_event_get_type(event, &eventType) == BBMSP_SUCCESS) {
                                switch (eventType) {
                                    case BBMSP_SP_EVENT_CONTACT_CHANGED:
                                    {
                                        processContactUpdate(bbmEvent);
                                    }
                                }
                            }
                        }
                    }
                }
            } else if (event_domain == m_BBMInternalDomain) {
                int code = bps_event_get_code(event);
                if (code == INTERNAL_EVENT_REGISTER) {
                    bps_event_payload_t *payload = bps_event_get_payload(event);
                    char *uuid = reinterpret_cast<char *>(payload->data1);
                    bbmsp_register(uuid);
                    delete uuid;
                } else if (code == INTERNAL_EVENT_CONTACT_EVENTS) {
                    bbmsp_event_contact_list_register_event();
                    contactEventsEnabled = true;
                } else if (code == INTERNAL_EVENT_STOP) {
                    break;
                }
            }
        }
    }
    return (status == BPS_SUCCESS) ? 0 : 1;
}