// TODO: Need to use ActivitySet for activity hanlding
SmtpSyncOutboxCommand::SmtpSyncOutboxCommand(SmtpClient& client, const MojObject& accountId, const MojObject& folderId, bool force, bool clear)
: SmtpCommand(client),
  m_client(client),
  m_accountId(accountId),
  m_folderId(folderId),
  m_highestRev(0),
  m_canAdopt(true),
  m_setSyncStatusSlot(this, &SmtpSyncOutboxCommand::SetSyncStatusResponse),
  m_clearSyncStatusSlot(this, &SmtpSyncOutboxCommand::ClearSyncStatusResponse),
  m_setSyncStatusSlot2(this, &SmtpSyncOutboxCommand::SetSyncStatusResponse2),
  m_clearSyncStatusSlot2(this, &SmtpSyncOutboxCommand::ClearSyncStatusResponse2),
  m_getOutboxEmailsSlot(this, &SmtpSyncOutboxCommand::GetOutboxEmailsResponse),
  m_sendDoneSlot(this, &SmtpSyncOutboxCommand::SendDone),
  m_activityUpdatedSlot(this, &SmtpSyncOutboxCommand::ActivityUpdated),
  m_activityErrorSlot(this, &SmtpSyncOutboxCommand::ActivityError),
  m_accountActivityUpdatedSlot(this, &SmtpSyncOutboxCommand::AccountActivityUpdated),
  m_accountActivityErrorSlot(this, &SmtpSyncOutboxCommand::AccountActivityError),
  m_getAccountSlot(this, &SmtpSyncOutboxCommand::GotAccount),
  m_temporaryError(false),
  m_createWatchActivitySlot(this, &SmtpSyncOutboxCommand::CreateWatchActivityResponse),
  m_createAccountWatchActivityResponseSlot(this, &SmtpSyncOutboxCommand::CreateAccountWatchResponse),
  m_findFolderSlot(this, &SmtpSyncOutboxCommand::FindOutgoingFolderResponse),
  m_updateRetrySlot(this, &SmtpSyncOutboxCommand::UpdateRetryResponse),
  m_updateErrorSlot(this, &SmtpSyncOutboxCommand::UpdateErrorResponse),
  m_resetErrorSlot(this, &SmtpSyncOutboxCommand::ResetErrorResponse),
  m_cancelled(false),
  m_force(force),
  m_clear(clear),
  m_networkStatus(new NetworkStatus()),
  m_networkActivityUpdatedSlot(this, &SmtpSyncOutboxCommand::NetworkActivityUpdated),
  m_networkActivityErrorSlot(this, &SmtpSyncOutboxCommand::NetworkActivityError)
{
	MojString d;
	m_accountId.stringValue(d);
	m_outboxWatchActivityName.format(SmtpActivityFactory::OUTBOX_WATCH_ACTIVITY_FMT, d.data());
	m_accountWatchActivityName.format(SmtpActivityFactory::ACCOUNT_WATCH_ACTIVITY_FMT, d.data());

#ifdef WEBOS_TARGET_MACHINE_STANDALONE
	MojObject cmStatus;
	MojErr err;
	err = cmStatus.put("isInternetConnectionAvailable", true);
    ErrorToException(err);
    m_networkStatus->ParseStatus(cmStatus);
#endif

}
MojErr AuthYahooCommand::GetYahooCookiesSlot(MojObject& response, MojErr err)
{
	MojLogTrace(m_log);
	try {
		ResponseToException(response, err);

		MojObject object;
		err = response.getRequired("tCookie", m_tCookie);
		ErrorToException(err);
	
		err = response.getRequired("yCookie", m_yCookie);
		ErrorToException(err);
	
	} catch (const std::exception& e) {
		MojLogInfo(m_log, "Failed to retrieve Yahoo cookies, failing login: %s", e.what());
		
		// FIXME: We should possibly try to decode and pass along a specific error
		
		SmtpSession::SmtpError error;
		error.errorCode = MailError::ACCOUNT_UNAVAILABLE;
		error.errorOnAccount = true;
		error.internalError = std::string("Unable to retrieve yahoo cookies: ") + e.what();
		m_session.AuthYahooFailure(error);
		Complete();
		
		return MojErrNone;
	} catch (...) {
		MojLogInfo(m_log, "Failed to retrieve Yahoo cookies, failing login: unknown exception");

		// FIXME: We should possibly try to decode and pass along a specific error

		SmtpSession::SmtpError error;
		error.errorCode = MailError::ACCOUNT_UNAVAILABLE;
		error.errorOnAccount = true;
		error.internalError = "Unable to retrieve yahoo cookies: unknown exception";
		m_session.AuthYahooFailure(error);
		Complete();

		return MojErrNone;
	}

	m_state = State_SendingYCookie;
	WriteCommand();
	
	return MojErrNone;
}
MojErr  OnEnabledHandler::getAccountInfoResult(MojObject& payload, MojErr resultErr)
{
	MojLogTrace(IMServiceApp::s_log);
	IMServiceHandler::logMojObjectJsonString(_T("OnEnabledHandler::getAccountInfoResult payload: %s"), payload);

	if (resultErr != MojErrNone) {
		MojLogError(IMServiceApp::s_log, _T("OnEnabledHandler getAccountInfo result error %d"), resultErr);
		return resultErr;
	}

	MojObject result;
	MojErr err = payload.getRequired("result", result);
	if (err != MojErrNone || result.empty()) {
		MojLogError(IMServiceApp::s_log, _T("OnEnabledHandler::getAccountInfoResult result empty or error %d"), err);
		return err;
	}

	MojString accountId;
	err = result.getRequired("_id", accountId);
	if (err != MojErrNone || accountId.empty()) {
		MojLogError(IMServiceApp::s_log, _T("OnEnabledHandler::getAccountInfoResult accountId empty or error %d"), err);
		return err;
	}

	MojString username;
	err = result.getRequired("username", username);
	if (err != MojErrNone || username.empty()) {
		MojLogError(IMServiceApp::s_log, _T("OnEnabledHandler::getAccountInfoResult username empty or error %d"), err);
		return err;
	}

	MojString serviceName;
	getServiceNameFromCapabilityId(serviceName);
	if (serviceName.empty()) {
		MojLogError(IMServiceApp::s_log, _T("OnEnabledHandler::getAccountInfoResult serviceName empty"));
		return err;
	}

	if (m_enable) {
		err = accountEnabled(accountId, serviceName, username);
	} else {
		err = accountDisabled(accountId, serviceName, username);
	}

	return err;
}
MojoObjectJson::MojoObjectJson(const MojObject& obj)
{
	MojErr err = obj.toJson(m_str);

	/* Intentially ignore err here.  This is for debug output, let's not
	 * make the problem worse... */
	(void)err;
}
MojErr MojDbServiceHandler::handleMerge(MojServiceMessage* msg, MojObject& payload, MojDbReq& req)
{
	MojAssert(msg);
	MojLogTrace(s_log);

	MojErr err = MojErrNone;
	MojUInt32 count = 0;
	MojObject obj;
	

	if (payload.get(MojDbServiceDefs::ObjectsKey, obj)) {
		if (payload.contains(MojDbServiceDefs::QueryKey))
			MojErrThrowMsg(MojErrInvalidArg, _T("db: cannot have both an objects param and a query param"));
		MojObject::ArrayIterator begin;
		bool ignoreM = false;
		payload.get(MojDbServiceDefs::IgnoreMissingKey, ignoreM);
		MojUInt32 mflags = MojDb::FlagNone;
		if (ignoreM)
			mflags = mflags | MojDb::FlagIgnoreMissing;
		err = obj.arrayBegin(begin);
		MojErrCheck(err);
		MojObject::ConstArrayIterator end = obj.arrayEnd();
		err = m_db.merge(begin, end, mflags, req);
		MojErrCheck(err);
		err = formatPut(msg, begin, end); // TO DO: we need to drop non-existing objects
		MojErrCheck(err);
	}
	else if (payload.get(MojDbServiceDefs::QueryKey, obj)) {
		MojObject props;
		err = payload.getRequired(MojDbServiceDefs::PropsKey, props);
		MojErrCheck(err);
		bool ignoreM = false;
		if (payload.get(MojDbServiceDefs::IgnoreMissingKey, ignoreM))
			MojErrThrowMsg(MojErrInvalidArg, _T("db: ignoreMissing - invalid option for merge query"));

		MojDbQuery query;
		err = query.fromObject(obj);
		MojErrCheck(err);
		MojUInt32 queryCount = 0;
		err = m_db.merge(query, props, queryCount, MojDb::FlagNone, req);
		MojErrCheck(err);
		count += queryCount;
		err = formatCount(msg, count);
		MojErrCheck(err);
	}
	else {
		MojErrThrowMsg(MojErrInvalidArg, _T("db: either objects or query param required for merge"));
	}

	return MojErrNone;
}
void TelephonyProxy::Enable()
{
	LOG_TRACE("Entering function %s", __FUNCTION__);
	LOG_DEBUG("Enabling TIL Proxy");

	MojObject params;
	params.putBool(_T("subscribe"), true);

	// Start out with a platformQuery
	m_platformQuery = boost::make_shared<MojoWeakPtrCall<TelephonyProxy> >(
		boost::dynamic_pointer_cast<TelephonyProxy, RequirementManager>
			(shared_from_this()),
		&TelephonyProxy::PlatformQueryUpdate, m_service,
		"palm://com.palm.telephony/platformQuery", params,
		MojoCall::Unlimited);
	m_platformQuery->Call();
}
MojErr MojoCompareMatcher::ToJson(MojObject& rep, unsigned long flags) const
{
	MojErr err;

	MojObject compare;

	err = compare.put(_T("key"), m_key);
	MojErrCheck(err);

	err = compare.put(_T("value"), m_value);
	MojErrCheck(err);

	err = rep.put(_T("compare"), compare);
	MojErrCheck(err);

	return MojErrNone;
}
void MojoDBProxy::PreparePurgeCall()
{
	LOG_TRACE("Entering function %s", __FUNCTION__);
	LOG_DEBUG("Preparing to purge batch of old Activities");

	MojObject ids(MojObject::TypeArray);
	PopulatePurgeIds(ids);

	MojObject params;
	params.put(_T("ids"), ids);

	m_call = boost::make_shared<MojoWeakPtrCall<MojoDBProxy> >(
		boost::dynamic_pointer_cast<MojoDBProxy, PersistProxy>
			(shared_from_this()),
		&MojoDBProxy::ActivityPurgeComplete,
		m_service, "palm://com.palm.db/del", params);
}
Example #9
0
	MojErr sendEcho(const MojChar* json, const MojObject& expectedResponse, const MojChar* method)
	{
		MojRefCountedPtr<EchoResponseHdlr> handler(new EchoResponseHdlr(expectedResponse, ++m_pendingResponseCount));
		MojAllocCheck(handler.get());

		MojRefCountedPtr<MojServiceRequest> req;
		MojErr err = m_service.createRequest(req);
		MojTestErrCheck(err);

		MojObject payload;
		err = payload.fromJson(json);
		MojTestErrCheck(err);
		err = req->send(handler->m_slot, ServiceName, method, payload);
		MojTestErrCheck(err);

		return MojErrNone;
	}
Example #10
0
MojErr MojDbQuotaEngine::put(MojObject& obj, MojDbReq& req, bool putObj)
{
	MojLogTrace(s_log);
	MojAssertWriteLocked(m_db->schemaLock());

	// check for admin permission
	if (!req.admin()) {
		MojErrThrow(MojErrDbPermissionDenied);
	}

	// pull params out of object
	MojString owner;
	MojErr err = obj.getRequired(MojDbServiceDefs::OwnerKey, owner);
	MojErrCheck(err);
	MojInt64 size = 0;
	err = obj.getRequired(MojDbServiceDefs::SizeKey, size);
	MojErrCheck(err);

	// validate owner
	err = validateWildcard(owner, MojErrDbInvalidOwner);
	MojErrCheck(err);

	// put object
	if (putObj) {
		MojString id;
		err = id.format(_T("_quotas/%s"), owner.data());
		MojErrCheck(err);
		err = obj.put(MojDb::IdKey, id);
		MojErrCheck(err);
		err = obj.putString(MojDb::KindKey, MojDbKindEngine::QuotaId);
		MojErrCheck(err);

		MojDbAdminGuard adminGuard(req);
		err = m_db->put(obj, MojDb::FlagForce, req);
		MojErrCheck(err);

		// defer commit of quota until txn commit
		MojRefCountedPtr<MojDbQuotaCommitHandler> handler(new MojDbQuotaCommitHandler(this, owner, size, req.txn()));
		MojAllocCheck(handler.get());
	} else {
		err = commitQuota(owner, size);
		MojErrCheck(err);
	}
	return MojErrNone;
}
void FileCacheClient::InsertCacheObject(ReplySignal::SlotRef slot, const char* typeName, const char* fileName, MojInt64 size, MojInt64 cost, MojInt64 lifetime)
{
    MojErr err;
    MojObject payload;

    err = payload.putString("typeName", typeName);
    ErrorToException(err);

    err = payload.putString("fileName", fileName);
    ErrorToException(err);

    // Size must be >0 and larger than the actual content.
    // If the content is empty, we'll use 1 so FileCache doesn't complain.
    err = payload.put("size", size > 0 ? size : 1);
    ErrorToException(err);

    if(cost >= 0) {
        err = payload.put("cost", cost);
        ErrorToException(err);
    }

    if(lifetime >= 0) {
        err = payload.put("lifetime", lifetime);
        ErrorToException(err);
    }

    err = payload.put("subscribe", true);
    ErrorToException(err);

    m_busClient.SendRequest(slot, FILECACHE_SERVICE, "InsertCacheObject", payload, MojServiceRequest::Unlimited);
}
MojErr PopAccountUpdateCommand::GetPasswordResponse(MojObject& response, MojErr err)
{
	CommandTraceFunction();

	try {
		// check the result first
		ErrorToException(err);

		MojObject credentials;
		err = response.getRequired("credentials", credentials);
		ErrorToException(err);

		MojString password;
		err = credentials.getRequired("password", password);
		ErrorToException(err);

		boost::shared_ptr<PopAccount> newPopAccount(new PopAccount());
		PopAccountAdapter::GetPopAccountFromTransportObject(m_transportObj, *(newPopAccount.get()));
		newPopAccount->SetPassword(password.data());

		boost::shared_ptr<PopAccount> oldPopAccount = m_client.GetAccount();

		if (!oldPopAccount.get()) {
			m_callSyncFolderOnClient = true;
		} else if (newPopAccount->GetPort() != oldPopAccount->GetPort() ||
			newPopAccount->GetEncryption() != oldPopAccount->GetEncryption() ||
			newPopAccount->GetUsername() != oldPopAccount->GetUsername() ||
			newPopAccount->GetSyncFrequencyMins() != oldPopAccount->GetSyncWindowDays() ||
			newPopAccount->GetHostName() != oldPopAccount->GetHostName()) {
			m_callSyncFolderOnClient = true;
		}
		
		// Should be initial sync if the old account does not exist 
		// or the old account is in initial sync state.
		newPopAccount->SetInitialSync(!oldPopAccount.get() || oldPopAccount->IsInitialSync());
		m_client.SetAccount(newPopAccount);
		UpdateAccountWatchActivity();
	} catch (const std::exception& ex) {
		Failure(ex);
	} catch (...) {
		Failure(MailException("unknown exception", __FILE__, __LINE__));
	}

	return MojErrNone;
}
Example #13
0
MojErr MojDbKindState::delIndex(const MojChar* indexName, MojDbReq& req)
{
	MojAssert(indexName);
	MojThreadGuard guard(m_lock);

	MojObject obj;
	MojRefCountedPtr<MojDbStorageItem> item;
	MojErr err = readIds(IndexIdsKey, req, obj, item);
	MojErrCheck(err);
	bool found = false;
	err = obj.del(indexName, found);
    MojErrCheck(err);
	MojAssert(found);
	err = writeIds(IndexIdsKey, obj, req, item);
	MojErrCheck(err);

	return MojErrNone;
}
Example #14
0
MojErr MojServiceMessage::replySuccess(MojObject& payload)
{
	MojErr err = payload.putBool(ReturnValueKey, true);
	MojErrCheck(err);
	err = reply(payload);
	MojErrCheck(err);

	return MojErrNone;
}
MojErr ControlGroup::ToJson(MojObject& rep) const
{
    std::string path = GetRoot() + "/" + m_name;

    MojErr err = rep.putString(_T("path"), path.c_str());
    MojErrCheck(err);

    return ResourceContainer::ToJson(rep);
}
void DownloadListener::BuildResponse(MojObject& payload, MojInt64 bytesDownloaded, MojInt64 totalBytes)
{
	MojErr err;

	err = payload.put("emailId", m_emailId);
	ErrorToException(err);

	if(!m_partId.undefined()) {
		err = payload.put("partId", m_partId);
		ErrorToException(err);
	}

	err = payload.put("bytesDownloaded", bytesDownloaded);
	ErrorToException(err);

	err = payload.put("totalBytes", totalBytes);
	ErrorToException(err);
}
Example #17
0
MojErr KindsModel::handleKindsList(MojObject& result, MojErr errCode)
{
	MojString str;
	result.toJson(str);

	result.getRequired(_T("results"))

	return MojErrNone;
}
void PopAccountUpdateCommand::GetPassword()
{
	try {
		MojObject params;
		MojErr err = params.put("accountId", m_accountId);
		ErrorToException(err);

		err = params.putString("name", "common");
		ErrorToException(err);

		err = m_client.CreateRequest()->send(m_getPasswordSlot, "com.palm.service.accounts","readCredentials", params);
		ErrorToException(err);
	} catch (const std::exception& ex) {
		Failure(ex);
	} catch (...) {
		Failure(MailException("unknown exception", __FILE__, __LINE__));
	}
}
Example #19
0
MojErr MojSchemaTest::checkValid(const MojChar* schemaJson, const MojChar* instanceJson, bool expected)
{
	MojObject schemaObj;
	MojErr err = schemaObj.fromJson(schemaJson);
	MojTestErrCheck(err);
	MojSchema schema;
	err = schema.fromObject(schemaObj);
	MojTestErrCheck(err);
	MojObject instance;
	err = instance.fromJson(instanceJson);
	MojTestErrCheck(err);
	MojSchema::Result res;
	err = schema.validate(instance, res);
	MojTestErrCheck(err);
	MojTestAssert(res.valid() == expected);

	return MojErrNone;
}
void MojoDBProxy::PrepareConfiguratorCall()
{
	LOG_TRACE("Entering function %s", __FUNCTION__);
	LOG_DEBUG("Prepared to update Activity configuration from static store");

	MojObject types(MojObject::TypeArray);

	types.pushString(_T("activities"));

	MojObject params;
	params.put(_T("types"), types);

	m_call = boost::make_shared<MojoWeakPtrCall<MojoDBProxy> >(
		boost::dynamic_pointer_cast<MojoDBProxy, PersistProxy>
			(shared_from_this()),
		&MojoDBProxy::ActivityConfiguratorComplete,
		m_service, "palm://com.palm.configurator/run", params);
}
Example #21
0
MojErr MojDbKindState::readObj(const MojChar* key, MojObject& val, MojDbStorageDatabase* db,
		MojDbStorageTxn* txn, MojRefCountedPtr<MojDbStorageItem>& oldItem)
{
	MojAssert(key && db);

	MojErr err = db->get(m_kindId, txn, false, oldItem);
	MojErrCheck(err);
	if (oldItem.get()) {
		// get objects
		MojObject obj;

		// TODO: this bugging ( on calling getObj)
		err = oldItem->toObject(obj, *m_kindEngine, false);
		MojErrCheck(err);
		obj.get(key, val);
	}
	return MojErrNone;
}
MojErr MojoKeyMatcher::ToJson(MojObject& rep, unsigned long flags) const
{
	MojErr err;

	err = rep.put(_T("key"), m_key);
	MojErrCheck(err);

	return MojErrNone;
}
Example #23
0
MojErr MojServiceMessage::reply(const MojObject& payload)
{
	MojErr err = payload.visit(writer());
	MojErrCheck(err);
	err = reply();
	MojErrCheck(err);

	return MojErrNone;
}
Example #24
0
MojErr MojDbPutHandler::configure(const MojObject& conf, MojDbReq& req)
{
    LOG_TRACE("Entering function %s", __FUNCTION__);
    MojAssertWriteLocked(m_db->schemaLock());

    // built-in permissions
    MojObject objects;
    if (conf.get(m_confProp, objects)) {
        MojObject::ConstArrayIterator end = objects.arrayEnd();
        for (MojObject::ConstArrayIterator i = objects.arrayBegin();
                i != end; ++i) {
            MojObject perm(*i);
            MojErr err = put(perm, req, false);
            MojErrCheck(err);
        }
    }
    return MojErrNone;
}
MojErr MojoWhereMatcher::ToJson(MojObject& rep, unsigned long flags) const
{
	MojErr err;

	err = rep.put(_T("where"), m_where);
	MojErrCheck(err);

	return MojErrNone;
}
Example #26
0
MojErr MojDbIndexTest::wildcardTest()
{
	MojDbIndex index(NULL, NULL);
	MojRefCountedPtr<TestIndex> storageIndex(new TestIndex(false));
	MojAllocCheck(storageIndex.get());
	TestIndex& ti = *storageIndex;

	MojObject prop;
	MojErr err = prop.putString(MojDbIndex::NameKey, _T("foo.*.bar"));
	MojTestErrCheck(err);
	err = index.addProp(prop);
	MojTestErrCheck(err);
	MojDbReq req;
	err = index.open(storageIndex.get(), (MojInt64) 0, req);
	MojTestErrCheck(err);

	err = put(index, 1, _T("{\"foo\":{\"bar\":1}}"), NULL);
	MojTestErrCheck(err);
	MojTestAssert(ti.m_putCount == 0 && ti.m_delCount == 0 && ti.m_set.size() == 0);
	err = put(index, 1, _T("{\"foo\":{\"1\":{\"bar\":1},\"2\":{\"bar\":2},\"3\":{\"bar\":3}}}"), NULL);
	MojTestErrCheck(err);
	MojTestAssert(ti.m_putCount == 3 && ti.m_delCount == 0 && ti.m_set.size() == 3);
	err = assertContains(ti, 1, 1);
	MojTestErrCheck(err);
	err = assertContains(ti, 1, 2);
	MojTestErrCheck(err);
	err = assertContains(ti, 1, 3);
	MojTestErrCheck(err);
	err = put(index, 1, _T("{\"foo\":{\"2\":{\"bar\":2},\"3\":{\"bar\":3}}}"), _T("{\"foo\":{\"1\":{\"bar\":1},\"2\":{\"bar\":2},\"3\":{\"bar\":3}}}"));
	MojTestErrCheck(err);
	MojTestAssert(ti.m_putCount == 3 && ti.m_delCount == 1 && ti.m_set.size() == 2);
	err = assertContains(ti, 1, 2);
	MojTestErrCheck(err);
	err = assertContains(ti, 1, 3);
	MojTestErrCheck(err);
	err = del(index, 1, _T("{\"foo\":{\"2\":{\"bar\":2},\"3\":{\"bar\":3}}}"));
	MojTestErrCheck(err);
	MojTestAssert(ti.m_putCount == 3 && ti.m_delCount == 3 && ti.m_set.size() == 0);

	err = index.close();
	MojTestErrCheck(err);

	return MojErrNone;
}
MojErr PowerdPowerActivity::RemoveRemotePowerActivity()
{
	LOG_AM_TRACE("Entering function %s", __FUNCTION__);

	MojErr err;
	MojObject params;

	err = params.putString(_T("id"), GetRemotePowerActivityName().c_str());
	MojErrCheck(err);

	m_call = boost::make_shared<MojoWeakPtrCall<PowerdPowerActivity> >(
		boost::dynamic_pointer_cast<PowerdPowerActivity, PowerActivity>(
			shared_from_this()),
		&PowerdPowerActivity::PowerUnlockedNotificationNormal, m_service,
		"palm://com.palm.power/com/palm/power/activityEnd", params);
	m_call->Call();

	return MojErrNone;
}
/*
 * Example messaging capability provider
 *  "capabilityProviders": [{
            "_id": "2+MR",
            "capability": "MESSAGING",
            "id": "com.palm.google.talk",
            "capabilitySubtype": "IM",
            "loc_name": "Google Talk",
            "icon": {
                "loc_32x32": "/usr/palm/public/accounts/com.palm.google/images/gtalk32x32.png",
                "loc_48x48": "/usr/palm/public/accounts/com.palm.google/images/gtalk48x48.png",
                "splitter": "/usr/palm/public/accounts/com.palm.google/images/gtalk_transport_splitter.png"
            },
            "implementation": "palm://com.palm.imlibpurple/",
            "onEnabled": "palm://com.palm.imlibpurple/onEnabled"
            "serviceName":"type_aim",
            "dbkinds": {
                "immessage":"com.palm.immessage.libpurple:1",
                "imcommand":"com.palm.imcommand.libpurple:1"
            }
    }],
 */
MojErr OnEnabledHandler::getMessagingCapabilityObject(const MojObject& capabilityProviders, MojObject& messagingObj)
{
	// iterate thru the capabilities array
	MojErr err = MojErrRequiredPropNotFound;
	MojString capability;
	MojObject::ConstArrayIterator itr = capabilityProviders.arrayBegin();
	// This shouldn't happen, but check if there's nothing to do.
	while (itr != capabilityProviders.arrayEnd()) {
		messagingObj = *itr;
		err = messagingObj.getRequired("capability", capability);
		if (capability == "MESSAGING") {
			err = MojErrNone;
			break;
		}
		++itr;
	}

	return err;
}
Example #29
0
MojErr MojDbPerfUpdateTest::putObjs(MojDb& db, const MojChar* kindId, MojUInt64 numInsert,
		MojErr (MojDbPerfTest::*createFn) (MojObject&, MojUInt64), MojObject& objs)
{
	for (MojUInt64 i = 0; i < numInsert; i++) {
		MojObject obj;
		MojErr err = obj.putString(MojDb::KindKey, kindId);
		MojTestErrCheck(err);
		err = (*this.*createFn)(obj, i);
		MojTestErrCheck(err);

		err = db.put(obj);
		MojTestErrCheck(err);

		err = objs.push(obj);
		MojTestErrCheck(err);
	}

	return MojErrNone;
}
void MojoDBProxy::LoadActivities()
{
	LOG_TRACE("Entering function %s", __FUNCTION__);
	LOG_DEBUG("Loading persisted Activities from MojoDB");

	MojObject query;
	query.putString(_T("from"), ActivityKind);

	MojObject params;
	params.put(_T("query"), query);

	m_call = boost::make_shared<MojoWeakPtrCall<MojoDBProxy> >(
		boost::dynamic_pointer_cast<MojoDBProxy, PersistProxy>
			(shared_from_this()),
		&MojoDBProxy::ActivityLoadResults,
		m_service, "palm://com.palm.db/find", params);

	m_call->Call();
}