/* * Copyright 2001-2010 Haiku, Inc. All rights reserved. * Distributed under the terms of the MIT License. * * Authors: * Ingo Weinhold, ingo_weinhold@gmx.de */ #include #include #include #include #include #include using namespace BPrivate; BMessageRunner::BMessageRunner(BMessenger target, const BMessage* message, bigtime_t interval, int32 count) : fToken(-1) { _InitData(target, message, interval, count, be_app_messenger); } BMessageRunner::BMessageRunner(BMessenger target, const BMessage& message, bigtime_t interval, int32 count) : fToken(-1) { _InitData(target, &message, interval, count, be_app_messenger); } BMessageRunner::BMessageRunner(BMessenger target, const BMessage* message, bigtime_t interval, int32 count, BMessenger replyTo) : fToken(-1) { _InitData(target, message, interval, count, replyTo); } BMessageRunner::BMessageRunner(BMessenger target, const BMessage& message, bigtime_t interval, int32 count, BMessenger replyTo) : fToken(-1) { _InitData(target, &message, interval, count, replyTo); } BMessageRunner::~BMessageRunner() { if (fToken < B_OK) return; // compose the request message BMessage request(B_REG_UNREGISTER_MESSAGE_RUNNER); status_t result = request.AddInt32("token", fToken); // send the request BMessage reply; if (result == B_OK) result = BRoster::Private().SendTo(&request, &reply, false); // ignore the reply, we can't do anything anyway } status_t BMessageRunner::InitCheck() const { return fToken >= 0 ? B_OK : fToken; } status_t BMessageRunner::SetInterval(bigtime_t interval) { return _SetParams(true, interval, false, 0); } status_t BMessageRunner::SetCount(int32 count) { return _SetParams(false, 0, true, count); } status_t BMessageRunner::GetInfo(bigtime_t* interval, int32* count) const { status_t result = fToken >= 0 ? B_OK : B_BAD_VALUE; // compose the request message BMessage request(B_REG_GET_MESSAGE_RUNNER_INFO); if (result == B_OK) result = request.AddInt32("token", fToken); // send the request BMessage reply; if (result == B_OK) result = BRoster::Private().SendTo(&request, &reply, false); // evaluate the reply if (result == B_OK) { if (reply.what == B_REG_SUCCESS) { // count int32 _count; if (reply.FindInt32("count", &_count) == B_OK) { if (count != 0) *count = _count; } else result = B_ERROR; // interval bigtime_t _interval; if (reply.FindInt64("interval", &_interval) == B_OK) { if (interval != 0) *interval = _interval; } else result = B_ERROR; } else { if (reply.FindInt32("error", &result) != B_OK) result = B_ERROR; } } return result; } /*static*/ status_t BMessageRunner::StartSending(BMessenger target, const BMessage* message, bigtime_t interval, int32 count) { int32 token = _RegisterRunner(target, message, interval, count, true, be_app_messenger); return token >= B_OK ? B_OK : token; } /*static*/ status_t BMessageRunner::StartSending(BMessenger target, const BMessage* message, bigtime_t interval, int32 count, BMessenger replyTo) { int32 token = _RegisterRunner(target, message, interval, count, true, replyTo); return token >= B_OK ? B_OK : token; } // FBC void BMessageRunner::_ReservedMessageRunner1() {} void BMessageRunner::_ReservedMessageRunner2() {} void BMessageRunner::_ReservedMessageRunner3() {} void BMessageRunner::_ReservedMessageRunner4() {} void BMessageRunner::_ReservedMessageRunner5() {} void BMessageRunner::_ReservedMessageRunner6() {} #ifdef _BEOS_R5_COMPATIBLE_ //! Privatized copy constructor to prevent usage. BMessageRunner::BMessageRunner(const BMessageRunner &) : fToken(-1) { } //! Privatized assignment operator to prevent usage. BMessageRunner& BMessageRunner::operator=(const BMessageRunner&) { return* this; } #endif /*! Initializes the BMessageRunner. The success of the initialization can (and should) be asked for via InitCheck(). \note As soon as the last message has been sent, the message runner becomes unusable. InitCheck() will still return \c B_OK, but SetInterval(), SetCount() and GetInfo() will fail. \param target Target of the message(s). \param message The message to be sent to the target. \param interval Period of time before the first message is sent and between messages (if more than one shall be sent) in microseconds. \param count Specifies how many times the message shall be sent. A value less than \c 0 for an unlimited number of repetitions. \param replyTo Target replies to the delivered message(s) shall be sent to. */ void BMessageRunner::_InitData(BMessenger target, const BMessage* message, bigtime_t interval, int32 count, BMessenger replyTo) { fToken = _RegisterRunner(target, message, interval, count, false, replyTo); } /*! Registers the BMessageRunner in the registrar. \param target Target of the message(s). \param message The message to be sent to the target. \param interval Period of time before the first message is sent and between messages (if more than one shall be sent) in microseconds. \param count Specifies how many times the message shall be sent. A value less than \c 0 for an unlimited number of repetitions. \param replyTo Target replies to the delivered message(s) shall be sent to. \return The token the message runner is registered with, or the error code while trying to register it. */ /*static*/ int32 BMessageRunner::_RegisterRunner(BMessenger target, const BMessage* message, bigtime_t interval, int32 count, bool detach, BMessenger replyTo) { status_t result = B_OK; if (message == NULL || count == 0 || (count < 0 && detach)) result = B_BAD_VALUE; // compose the request message BMessage request(B_REG_REGISTER_MESSAGE_RUNNER); if (result == B_OK) result = request.AddInt32("team", BPrivate::current_team()); if (result == B_OK) result = request.AddMessenger("target", target); if (result == B_OK) result = request.AddMessage("message", message); if (result == B_OK) result = request.AddInt64("interval", interval); if (result == B_OK) result = request.AddInt32("count", count); if (result == B_OK) result = request.AddMessenger("reply_target", replyTo); // send the request BMessage reply; if (result == B_OK) result = BRoster::Private().SendTo(&request, &reply, false); int32 token; // evaluate the reply if (result == B_OK) { if (reply.what == B_REG_SUCCESS) { if (reply.FindInt32("token", &token) != B_OK) result = B_ERROR; } else { if (reply.FindInt32("error", &result) != B_OK) result = B_ERROR; } } if (result == B_OK) return token; return result; } /*! Sets the message runner's interval and count parameters. The parameters \a resetInterval and \a resetCount specify whether the interval or the count parameter respectively shall be reset. At least one parameter must be set, otherwise the methods returns \c B_BAD_VALUE. \param resetInterval \c true, if the interval shall be reset, \c false otherwise -- then \a interval is ignored. \param interval The new interval in microseconds. \param resetCount \c true, if the count shall be reset, \c false otherwise -- then \a count is ignored. \param count Specifies how many times the message shall be sent. A value less than \c 0 for an unlimited number of repetitions. \return A status code. \retval B_OK Everything went fine. \retval B_BAD_VALUE The message runner is not longer valid. All the messages that had to be sent have already been sent. Or both \a resetInterval and \a resetCount are \c false. */ status_t BMessageRunner::_SetParams(bool resetInterval, bigtime_t interval, bool resetCount, int32 count) { if ((!resetInterval && !resetCount) || fToken < 0) return B_BAD_VALUE; // compose the request message BMessage request(B_REG_SET_MESSAGE_RUNNER_PARAMS); status_t result = request.AddInt32("token", fToken); if (result == B_OK && resetInterval) result = request.AddInt64("interval", interval); if (result == B_OK && resetCount) result = request.AddInt32("count", count); // send the request BMessage reply; if (result == B_OK) result = BRoster::Private().SendTo(&request, &reply, false); // evaluate the reply if (result == B_OK) { if (reply.what != B_REG_SUCCESS) { if (reply.FindInt32("error", &result) != B_OK) result = B_ERROR; } } return result; }