Exemple #1
0
ECode CGestureStore::SaveEx(
    /* [in] */ IOutputStream * stream,
    /* [in] */ Boolean closeStream)
{
    VALIDATE_NOT_NULL(stream);
    /*
	AutoPtr<IBufferedOutputStream> outs;
	if (FAILED(CBufferedOutputStream::New(stream,
			                               GestureConstants::IO_BUFFER_SIZE,
			                               (IBufferedOutputStream **) &outs)))
	{
		return E_RUNTIME_EXCEPTION;
	}
	*/

    AutoPtr<IDataOutputStream> out;
    if (FAILED(CDataOutputStream::New(stream,(IDataOutputStream **) &out)))
    {
        return E_RUNTIME_EXCEPTION;
    }

    Int64 start;
    if (PROFILE_LOADING_SAVING) {
        start = SystemClock::GetElapsedRealtime();
    }

    HashMap<String, List<IGesture*> *> *maps = mNamedGestures;

    IDataOutput *dout=IDataOutput::Probe(out);
    // Write version number
    dout->WriteInt16(FILE_FORMAT_VERSION);
    // Write number of entries
    dout->WriteInt32(maps->GetSize());

    HashMap<String, List<IGesture*> *>::Iterator iter = maps->Begin();
    for (Int32 i=0; iter!=maps->End(); ++iter, ++i) {
        String key= iter->mFirst;
        List<IGesture*> *examples= iter->mSecond;
        Int32 count = examples->GetSize();

        // Write entry name
        ArrayOf<Byte>* utf = StringToByteArray(key);
        dout->WriteBytes(*utf); //??no WriteUTF api
        ArrayOf<Byte>::Free(utf);

        // Write number of examples for this entry
        dout->WriteInt32(count);

        for (Int32 j = 0; j < count; j++) {
            ((IGesture*)((*examples)[i]))->Serialize(out);
        }
    }
    stream->Flush(); //no Flush api

    if (PROFILE_LOADING_SAVING) {
        Int64 end = SystemClock::GetElapsedRealtime();
        Int64 diff= end - start;
        String tmp = String::FromInt64(diff);
        String log = String("Saving gestures library = ") + tmp + String(" ms");
        Logger::D(LOG_TAG,log.string());
    }

    mChanged = FALSE;
    if (closeStream) {
        CGestureUtils::CloseStream((ICloseable *)stream);
    }

    return NOERROR;

}
ECode CTextServicesManagerService::BuildSpellCheckerMapLocked(
    IContext* context,
    List<AutoPtr<ISpellCheckerInfo> >& list,
    HashMap<String, AutoPtr<ISpellCheckerInfo> >& map,
    TextServicesSettings* settings)
{
    // TODO
    return NOERROR;

    list.Clear();
    map.Clear();
    const AutoPtr<IPackageManager> pm;
    context->GetPackageManager((IPackageManager**)&pm);
    assert(pm != NULL);
    AutoPtr<IObjectContainer> services;
    AutoPtr<IIntent> intent;
    Int32 currentUserId;
    FAIL_RETURN(CIntent::New(String("android.service.textservice.SpellCheckerService"), (IIntent**)&intent));
    settings->GetCurrentUserId(&currentUserId);
    FAIL_RETURN(pm->QueryIntentServicesAsUser(intent, IPackageManager::GET_META_DATA, currentUserId, (IObjectContainer**)&services));
    if (services != NULL) {
        AutoPtr<IObjectEnumerator> enumerator;
        services->GetObjectEnumerator((IObjectEnumerator**)&enumerator);
        Boolean hasNext = FALSE;
        while(enumerator->MoveNext(&hasNext), hasNext) {
            AutoPtr<IResolveInfo> ri;
            AutoPtr<IServiceInfo> si;
            enumerator->Current((IInterface**)&ri);
            assert(ri != NULL);
            ri->GetServiceInfo((IServiceInfo**)&si);
            String packageName, name, permission;
            assert(si != NULL);
            si->GetPackageName(&packageName);
            si->GetName(&name);
            si->GetPermission(&permission);
            AutoPtr<IComponentName> compName;
            CComponentName::New(packageName, name, (IComponentName**)&compName);
            String strCompName;
            compName->ToString(&strCompName);
            if (!Elastos::Droid::Manifest::Permission::BIND_TEXT_SERVICE.Equals(permission)) {
                Slogger::W(TAG, "Skipping text service %s : it does not require the permission: %s ", strCompName.string(), Elastos::Droid::Manifest::Permission::BIND_TEXT_SERVICE.string());
                continue;
            }
            if (DBG) Slogger::D(TAG, "Add: %s", strCompName.string());
            //try {
            AutoPtr<ISpellCheckerInfo> sci;
            // CSpellCheckerInfo::New(context, ri, (ISpellCheckerInfo**)&sci);
            assert(0);
            Int32 subtypeCount;
            sci->GetSubtypeCount(&subtypeCount);
            if (subtypeCount <= 0) {
                Slogger::W(TAG, "Skipping text service %s : it does not contain subtypes.", strCompName.string());
                continue;
            }
            list.PushBack(sci);
            String sciId;
            sci->GetId(&sciId);
            map[sciId] = sci;
            // } catch (XmlPullParserException e) {
            //     Slog.w(TAG, "Unable to load the spell checker " + compName, e);
            // } catch (IOException e) {
            //     Slog.w(TAG, "Unable to load the spell checker " + compName, e);
            // }
        }
        if (DBG) {
            Slogger::D(TAG, "buildSpellCheckerMapLocked: %d, %d", list.GetSize(), map.GetSize());
        }
    }
    return NOERROR;
}