Example #1
0
ECode CVariableOfStruct::GetStructFieldGetter(
    /* [in] */ const String& name,
    /* [out] */ IStructGetter** getter)
{
    if (name.IsNull() || !getter) {
        return E_INVALID_ARGUMENT;
    }

    Int32 index = 0;
    ECode ec = GetIndexByName(name, &index);
    if (FAILED(ec)) return ec;

    if (mStructFieldDesc[index].mType != CarDataType_Struct) {
        return E_INVALID_ARGUMENT;
    }

    AutoPtr<IFieldInfo> fieldInfo;
    AutoPtr<IStructInfo> structInfo;
    ec = mStructInfo->GetFieldInfo(name, (IFieldInfo **)&fieldInfo);
    if (FAILED(ec)) return ec;

    ec = fieldInfo->GetTypeInfo((IDataTypeInfo **)&structInfo);
    if (FAILED(ec)) return ec;

    AutoPtr<IVariableOfStruct> variable;
    ec = structInfo->CreateVariableBox(
            mVarBuf + mStructFieldDesc[index].mPos, (IVariableOfStruct **)&variable);
    if (FAILED(ec)) return ec;

    return variable->GetGetter(getter);
}
Example #2
0
String CFileRotator::GetActiveName(
    /* [in] */ Int64 currentTimeMillis)
{
    String oldestActiveName;
    Int64 oldestActiveStart = Elastos::Core::Math::INT64_MAX_VALUE;

    AutoPtr<FileInfo> info = new FileInfo(mPrefix);
    AutoPtr< ArrayOf<String> > files;
    ASSERT_SUCCEEDED(mBasePath->List((ArrayOf<String>**)&files))
    for (Int32 i = 0; i < files->GetLength(); ++i) {
        String name = (*files)[i];
        if (!info->Parse(name)) continue;

        // pick the oldest active file which covers current time
        if (info->IsActive() && info->mStartMillis < currentTimeMillis
                && info->mStartMillis < oldestActiveStart) {
            oldestActiveName = name;
            oldestActiveStart = info->mStartMillis;
        }
    }

    if (!oldestActiveName.IsNull()) {
        return oldestActiveName;
    }
    else {
        // no active file found above; create one starting now
        info->mStartMillis = currentTimeMillis;
        info->mEndMillis = Elastos::Core::Math::INT64_MAX_VALUE;
        return info->Build();
    }
}
ECode CActivityOptions::Update(
    /* [in] */ IActivityOptions* otherOptions)
{
    assert(otherOptions != NULL);
    String pkgName;
    otherOptions->GetPackageName(&pkgName);
    if (!pkgName.IsNull()) {
        mPackageName = pkgName;
    }

    Int32 animationType;
    otherOptions->GetAnimationType(&animationType);
    AutoPtr<IRemoteCallback> callback;
    otherOptions->GetOnAnimationStartListener((IRemoteCallback**)&callback);
    switch (animationType) {
        case IActivityOptions::ANIM_CUSTOM:
            mAnimationType = animationType;
            otherOptions->GetCustomEnterResId(&mCustomEnterResId);
            otherOptions->GetCustomExitResId(&mCustomExitResId);
            mThumbnail = NULL;
            if (callback != NULL) {
                // try {
                    callback->SendResult(NULL);
                // } catch (RemoteException e) {
                // }
            }
            mAnimationStartedListener = callback;
            break;
        case IActivityOptions::ANIM_SCALE_UP:
            mAnimationType = animationType;
            otherOptions->GetStartX(&mStartX);
            otherOptions->GetStartX(&mStartY);
            otherOptions->GetStartWidth(&mStartWidth);
            otherOptions->GetStartHeight(&mStartHeight);
            if (callback != NULL) {
                // try {
                    callback->SendResult(NULL);
                // } catch (RemoteException e) {
                // }
            }
            mAnimationStartedListener = NULL;
            break;
        case IActivityOptions::ANIM_THUMBNAIL_SCALE_UP:
        case IActivityOptions::ANIM_THUMBNAIL_SCALE_DOWN:
            mAnimationType = animationType;
            mThumbnail = NULL;
            otherOptions->GetThumbnail((IBitmap**)&mThumbnail);
            otherOptions->GetStartX(&mStartX);
            otherOptions->GetStartX(&mStartY);
            if (callback != NULL) {
                // try {
                    callback->SendResult(NULL);
                // } catch (RemoteException e) {
                // }
            }
            mAnimationStartedListener = callback;
            break;
    }
    return NOERROR;
}
ECode PreferenceActivity::OnHeaderClick(
    /* [in] */ IPreferenceActivityHeader* header,
    /* [in] */ Int32 position)
{
    String fragment;
    header->GetFragment(&fragment);
    AutoPtr<IIntent> intent;
    if (!fragment.IsNull()) {
        if (mSinglePane) {
            Int32 titleRes;
            header->GetBreadCrumbTitleRes(&titleRes);
            Int32 shortTitleRes;
            header->GetBreadCrumbShortTitleRes(&shortTitleRes);
            if (titleRes == 0) {
                header->GetTitleRes(&titleRes);
                shortTitleRes = 0;
            }
            AutoPtr<IBundle> fragmentArguments;
            header->GetFragmentArguments((IBundle**)&fragmentArguments);
            StartWithFragment(fragment, fragmentArguments, NULL, 0, titleRes, shortTitleRes);
        }
        else {
            SwitchToHeader(header);
        }
    }
    else if (header->GetIntent((IIntent**)&intent), intent != NULL) {
        StartActivity(intent);
    }

    return NOERROR;
}
ECode CTrustAnchor::constructor(
    /* [in] */ const String& caName,
    /* [in] */ IPublicKey *caPublicKey,
    /* [in] */ ArrayOf<Byte> *nameConstraints)
{
    if (caName.IsNull()) {
        return E_NULL_POINTER_EXCEPTION;
    }
    mCaName = caName;
    if (caPublicKey == NULL) {
        return E_NULL_POINTER_EXCEPTION;
    }
    mCaPublicKey = caPublicKey;
    // copy nameConstraints if not null
    if (nameConstraints->GetLength()) {
        mNameConstraints = ArrayOf<Byte>::Alloc(nameConstraints->GetLength());
        mNameConstraints->Copy(0, nameConstraints, 0, mNameConstraints->GetLength());
        ProcessNameConstraints();
    }
    else {
        mNameConstraints = NULL;
    }
    mTrustedCert = NULL;

    // X500Principal checks caName validity
    if (caName.IsEmpty()) {
        return E_ILLEGAL_ARGUMENT_EXCEPTION;
    }
    AutoPtr<IX500Principal> principal;
    CX500Principal::New(mCaName, (IX500Principal**)&principal);
    mCaPrincipal = principal;
    return NOERROR;
}
Example #6
0
void SettingsHelper::SetRingtone(
    /* [in] */ const String& name,
    /* [in] */ const String& value)
{
    // If it's null, don't change the default
    if (value.IsNull()) return;
    AutoPtr<IUri> ringtoneUri;
    if (SILENT_RINGTONE.Equals(value)) {
    }
    else {
        AutoPtr<IUriHelper> helper;
        CUriHelper::AcquireSingleton((IUriHelper**)&helper);
        AutoPtr<IUri> canonicalUri;
        helper->Parse(value, (IUri**)&canonicalUri);
        AutoPtr<IContentResolver> resolver;
        mContext->GetContentResolver((IContentResolver**)&resolver);
        resolver->Uncanonicalize(canonicalUri, (IUri**)&ringtoneUri);
        if (ringtoneUri == NULL) {
            // Unrecognized or invalid Uri, don't restore
            return;
        }
    }
    const Int32 ringtoneType = ISettingsSystem::RINGTONE.Equals(name)
            ? IRingtoneManager::TYPE_RINGTONE : IRingtoneManager::TYPE_NOTIFICATION;

    AutoPtr<IRingtoneManagerHelper> helper;
    CRingtoneManagerHelper::AcquireSingleton((IRingtoneManagerHelper**)&helper);

    helper->SetActualDefaultRingtoneUri(mContext, ringtoneType, ringtoneUri);
}
//@Override // Binder call
ECode CDisplayManagerService::ForgetWifiDisplay(
    /* [in] */ const String& address)
{
    if (DEBUG) Slogger::D(TAG, "ForgetWifiDisplay address: [%s]", address.string());

    if (address.IsNull()) {
        Slogger::E(TAG, "address must not be NULL");
        return E_ILLEGAL_ARGUMENT_EXCEPTION;
    }

    if (!CanCallerConfigureWifiDisplay()) {
        Slogger::E(TAG, "Requires CONFIGURE_WIFI_DISPLAY "
            "permission to forget a wifi display.");
        return E_SECURITY_EXCEPTION;
    }

    Int64 token = Binder::ClearCallingIdentity();
    {
        AutoLock lock(mSyncRoot);
        if (mWifiDisplayAdapter != NULL) {
            mWifiDisplayAdapter->RequestForgetLocked(address);
        }
    }
    Binder::RestoreCallingIdentity(token);

    return NOERROR;
}
Example #8
0
String ContentProvider::GetAuthorityWithoutUserId(
    /* [in] */ const String& auth)
{
    if (auth.IsNull()) return String(NULL);
    Int32 end = auth.LastIndexOf('@');
    return auth.Substring(end + 1);
}
Example #9
0
ECode ContentProvider::OpenTypedAssetFile(
    /* [in] */ IUri* uri,
    /* [in] */ const String& mimeTypeFilter,
    /* [in] */ IBundle* opts,
    /* [out] */ IAssetFileDescriptor** fileDescriptor)
{
    VALIDATE_NOT_NULL(fileDescriptor)
    *fileDescriptor = NULL;

    if (mimeTypeFilter.Equals("*/*")) {
        // If they can take anything, the untyped open call is good enough.
        return OpenAssetFile(uri, String("r"), fileDescriptor);
    }
    String baseType;
    GetType(uri, &baseType);
    if (!baseType.IsNull()) {
        AutoPtr<IClipDescriptionHelper> descriptionHelper;
        CClipDescriptionHelper::AcquireSingleton((IClipDescriptionHelper**)&descriptionHelper);
        Boolean result = FALSE;
        descriptionHelper->CompareMimeTypes(baseType, mimeTypeFilter, &result);
        // Use old untyped open call if this provider has a type for this
        // URI and it matches the request.
        if (result) return OpenAssetFile(uri, String("r"), fileDescriptor);
    }
    // throw new FileNotFoundException("Can't open " + uri + " as type " + mimeTypeFilter);
    String str = Object::ToString(uri);
    Logger::E(TAG, "Can't open %s as type %s", str.string(), mimeTypeFilter.string());
    return E_FILE_NOT_FOUND_EXCEPTION;
}
Example #10
0
Boolean FontFamily::NativeAddFontFromAsset(
    /* [in] */ Int64 familyPtr,
    /* [in] */ IAssetManager* assetMgr,
    /* [in] */ const String& path)
{
    if (assetMgr == NULL || path.IsNull()) {
        return FALSE;
    }

    android::AssetManager* mgr = (android::AssetManager*)((CAssetManager*)assetMgr)->Ni();
    if (NULL == mgr) {
        return FALSE;
    }

    android::Asset* asset = mgr->open(path.string(), android::Asset::ACCESS_BUFFER);
    if (NULL == asset) {
        return FALSE;
    }

    SkStream* stream = new AssetStreamAdaptor(asset,
                                              AssetStreamAdaptor::kYes_OwnAsset,
                                              AssetStreamAdaptor::kYes_HasMemoryBase);
    SkTypeface* face = SkTypeface::CreateFromStream(stream);
    // Note: SkTypeface::CreateFromStream holds its own reference to the stream
    stream->unref();
    if (face == NULL) {
        Logger::E(String("FontFamily"), String("addFontFromAsset failed to create font %s"), path.string());
        return FALSE;
    }
    android::FontFamily* fontFamily = reinterpret_cast<android::FontFamily*>(familyPtr);
    return addSkTypeface(fontFamily, face);
}
Example #11
0
Boolean URLUtil::IsHttpsUrl(
    /* [in] */ const String& url)
{
    return (!url.IsNull()) &&
               (url.GetLength() > 7) &&
               url.Substring(0, 8).EqualsIgnoreCase("https://");
}
ECode CEmojiFactory::GetAndroidPuaFromVendorSpecificPua(
    /* [in] */ const String& vspString,
    /* [out] */ String* retValue)
{
    VALIDATE_NOT_NULL(retValue);
    *retValue = NULL;

    if (vspString.IsNull()) {
        return E_NULL_POINTER_EXCEPTION;
    }

    Int32 minVsp = NativeGetMinimumVendorSpecificPua(mNativeEmojiFactory);
    Int32 maxVsp = NativeGetMaximumVendorSpecificPua(mNativeEmojiFactory);

    AutoPtr<ArrayOf<Int32> > codePoints = ArrayOf<Int32>::Alloc(vspString.GetCharCount(0, len));\
    Int32 new_len = 0;

    for (Int32 i=0; i < len; i++,new_len++)
        Int32 codePoint = (Int32)vspString.GetChar(i);
        if (minVsp <= codePoint && codePoint <= maxVsp) {
            Int32 newCodePoint = GetAndroidPuaFromVendorSpecificPua(codePoint);
            if (newCodePoint > 0) {
                    (*codePoints)[new_len] = newCodePoint;
                    continue;
            }
        }
        (*codePoints)[new_len] = codePoint;
    }
Example #13
0
void CProxyProperties::SetExclusionList(
    /* [in] */ const String& exclusionList)
{
    mExclusionList = exclusionList.ToLowerCase();
    if (exclusionList.IsNull()) {
        mParsedExclusionList = ArrayOf<String>::Alloc(0);
    }
    else {
       AutoPtr <ArrayOf<String> >splitExclusionList;
       StringUtils::Split(mExclusionList, String(","), (ArrayOf<String>**)&splitExclusionList);
       Int32 length;
       length = splitExclusionList->GetLength();
       mParsedExclusionList = ArrayOf<String>::Alloc(length* 2);
       for (int i = 0; i < length; i++) {
           String str;
           str = (*splitExclusionList)[i];
           String s = str.Trim();
           if (s.StartWith(".")) {
               s = s.Substring(1);
           }
           String temp = String(".") + s;
           mParsedExclusionList->Set(i*2, s);
           mParsedExclusionList->Set((i*2)+1, temp);
       }
    }
}
Example #14
0
ECode CProxyProperties::IsExcluded(
    /* [in] */ const String& url,
    /* [out] */ Boolean* result)
{
    VALIDATE_NOT_NULL(result);
    Int32 length;
    length = mParsedExclusionList->GetLength();
    AutoPtr<ICharSequence> chars;
    CStringWrapper::New(url, (ICharSequence**)&chars);
    if (TextUtils::IsEmpty((ICharSequence*)&chars) || mParsedExclusionList == NULL ||length == 0) {
        *result = FALSE;
        return NOERROR;
    }
    AutoPtr<IUri> u;
    Uri::Parse(url, (IUri**)&u);
    String urlDomain;
    u->GetHost(&urlDomain);

    if (urlDomain.IsNull()) {
        *result = FALSE;
        return NOERROR;
    }
    Int32 length2;
    length2 = mParsedExclusionList->GetLength();
    for (Int32 i = 0; i< length2; i+=2) {
        if (urlDomain.Equals((*mParsedExclusionList)[i]) || urlDomain.EndWith((*mParsedExclusionList)[i+1])) {
            *result =  TRUE;
            return NOERROR;
        }
    }
    *result = FALSE;
    return NOERROR;
}
Example #15
0
ECode CClassInfo::GetConstructorInfoByParamNames(
    /* [in] */ const String& name,
    /* [out] */ IConstructorInfo** constructorInfo)
{
    if (name.IsNull() || !constructorInfo) {
        return E_INVALID_ARGUMENT;
    }

    if (!(mDesc->dwAttribs & ClassAttrib_hasctor)) {
        return E_DOES_NOT_EXIST;
    }

    ECode ec = AcquireConstructorList();
    if (FAILED(ec)) return ec;

    String objName("CreateObjectWith");
    objName += name;

    ec = mCtorList->AcquireObjByName(objName,
            (IInterface **)constructorInfo);
    if (FAILED(ec)) return ec;

    CConstructorInfo* consInfoObj = (CConstructorInfo*)(*constructorInfo);
    consInfoObj->mInstClsId.clsid = mClsId.clsid;
    strcpy(consInfoObj->mInstClsId.pUunm, mClsId.pUunm);

    return NOERROR;
}
Example #16
0
ECode IconPackHelper::LoadIconPack(
    /* [in] */ const String& packageName)
{
    if (packageName.IsNull()) {
        mLoadedIconPackResource = NULL;
        mLoadedIconPackName = NULL;
        mComposedIconInfo->SetIconBacks(NULL);
        mComposedIconInfo->SetIconMask(0);
        mComposedIconInfo->SetIconUpon(0);
        mComposedIconInfo->SetIconScale(0);
        mComposedIconInfo->SetColorFilter(NULL);
    }
    else {
        mIconBackCount = 0;
        AutoPtr<IResources> res;
        FAIL_RETURN(CreateIconResource(mContext, packageName, (IResources**)&res));
        FAIL_RETURN(GetIconResMapFromXml(res, packageName, (IMap**)&mIconPackResourceMap));
        mLoadedIconPackResource = res;
        mLoadedIconPackName = packageName;
        LoadComposedIconComponents();
        AutoPtr<IColorMatrix> cm;
        mFilterBuilder->Build((IColorMatrix**)&cm);
        if (cm != NULL) {
            AutoPtr< ArrayOf<Float> > arr;
            cm->GetArray((ArrayOf<Float>**)&arr);
            AutoPtr< ArrayOf<Float> > arrClone = arr->Clone();
            mComposedIconInfo->SetColorFilter(arrClone);
        }
    }
    return NOERROR;
}
Example #17
0
ECode SystemProperties::Set(
    /* [in] */ const String& key,
    /* [in] */ const String& val)
{
    if (key.IsNull() || key.GetLength() > PROP_NAME_MAX) {
//        throw new IllegalArgumentException("key.length > " + PROP_NAME_MAX);
        return E_ILLEGAL_ARGUMENT_EXCEPTION;
    }
    if (!val.IsNull() && val.GetLength() > PROP_VALUE_MAX) {
//        throw new IllegalArgumentException("val.length > " +
//            PROP_VALUE_MAX);
        return E_ILLEGAL_ARGUMENT_EXCEPTION;
    }
    NativeSet(key, val);
    return NOERROR;
}
Example #18
0
ECode CSizeF::ParseSizeF(
    /* [in] */ const String& string,
    /* [out] */ ISizeF** size)
{
    VALIDATE_NOT_NULL(size)
    *size = NULL;

    if (string.IsNull()) {
        return E_ILLEGAL_ARGUMENT_EXCEPTION;
    }
    //checkNotNull(string, "string must not be null");

    Int32 sep_ix = string.IndexOf('*');
    if (sep_ix < 0) {
        sep_ix = string.IndexOf('x');
    }
    if (sep_ix < 0) {
        // throw invalidSize(string);
        return E_NUMBER_FORMAT_EXCEPTION;
    }

    // try {
    Float w, h;
    FAIL_RETURN(StringUtils::Parse(string.Substring(0, sep_ix), &w))
    FAIL_RETURN(StringUtils::Parse(string.Substring(sep_ix + 1), &h))

    AutoPtr<CSizeF> s;
    CSizeF::NewByFriend(w, h, (CSizeF**)&s);
    *size = (ISizeF*)s.Get();
    REFCOUNT_ADD(*size)
    // } catch (NumberFormatException e) {
    //     throw invalidSize(string);
    // }
    return NOERROR;
}
Example #19
0
/**
* Add a gesture for the entry
*
* @param entryName entry name
* @param gesture
*/
ECode CGestureStore::AddGesture(
    /* [in] */ const String & entryName,
    /* [in] */ IGesture *gesture)
{
    VALIDATE_NOT_NULL(gesture);
    if (entryName.IsNull() || entryName.GetLength() == 0) {
        return NOERROR;
    }

    HashMap<String, List<IGesture*> *>::Iterator it=mNamedGestures->Find(entryName);
    List<IGesture*>* gestures = NULL;
    if (it != mNamedGestures->End())
        gestures = it->mSecond;

    if (gestures == NULL) {
        gestures = new List<IGesture*>();
        (*mNamedGestures)[entryName] = gestures;
    }
    gestures->PushBack(gesture);
    IInstance * ins = NULL;
    ECode ec = NOERROR;
    ec = CInstance::CreateInstance(mSequenceType, mOrientationStyle, gesture, entryName, &ins);
    ec = mClassifier->AddInstance(ins);
    if (!(FAILED(ec)))
        mChanged = TRUE;
    return ec;
}
Example #20
0
String CdmaMmiCode::MakeEmptyNull(
    /* [in] */ const String& s)
{
    if (!s.IsNull() && s.GetLength() == 0) return String(NULL);

    return s;
}
ECode CInstrumentationTestRunner::WatcherResultPrinter::AddFailure(
    /* [in] */ ITest* test,
    /* [in] */ ITestFailure* failure)
{
    String message;
    failure->ExceptionMessage(&message);
    String trace;
    failure->Trace(&trace);
    message.Append("\n");
    message.Append(trace);
    trace = message;
    String prevTrace;
    mTestResult->GetString(REPORT_KEY_STACK, &prevTrace);
    if (!prevTrace.IsNull()) {
        prevTrace.Append("\n");
        prevTrace.Append(trace);
        trace = prevTrace;
    }
    mTestResult->PutString(REPORT_KEY_STACK, trace);
    mTestResultCode = IInstrumentationTestRunner::REPORT_VALUE_RESULT_FAILURE;
    // pretty printing
    String name;
    ITestCase::Probe(test)->GetName(&name);
    String result;
    result.AppendFormat("\nFailure in %s:\n%s", name.string(), trace.string());
    mTestResult->PutString(IInstrumentation::REPORT_KEY_STREAMRESULT, result);
    return NOERROR;
}
Example #22
0
ECode CKXmlSerializer::StartDocument(
    /* [in] */ const String& encoding,
    /* [in] */ Boolean standalone)
{
    FAIL_RETURN(IWriter::Probe(mWriter)->Write(String("<?xml version='1.0' ")));

    if (!encoding.IsNull()) {
        mEncoding = encoding;
        if (encoding.StartWithIgnoreCase("utf")) { /*encoding.ToLowerCase(Locale.US).StartWith("utf")*/
            mUnicode = TRUE;
        }
    }

    if (!mEncoding.IsNull()) {
        FAIL_RETURN(IWriter::Probe(mWriter)->Write(String("encoding='")));
        FAIL_RETURN(IWriter::Probe(mWriter)->Write(mEncoding));
        FAIL_RETURN(IWriter::Probe(mWriter)->Write(String("' ")));
    }

    FAIL_RETURN(IWriter::Probe(mWriter)->Write(String("standalone='")));
    FAIL_RETURN(IWriter::Probe(mWriter)->Write(
        standalone ? String("yes") : String("no")));
    FAIL_RETURN(IWriter::Probe(mWriter)->Write(String("' ")));

    return IWriter::Probe(mWriter)->Write(String("?>"));
}
ECode HttpURLConnection::GetResponseCode(
    /* [out] */ Int32* responseCode)
{
    VALIDATE_NOT_NULL(responseCode)

    // Call getInputStream() first since getHeaderField() doesn't return
    // exceptions
    AutoPtr<IInputStream> is;
    FAIL_RETURN(GetInputStream((IInputStream**)&is));
    String response;
    GetHeaderField(0, &response);
    if (response.IsNull()) {
        *responseCode = -1;
        return NOERROR;
    }
    response = response.Trim();
    Int32 mark = response.IndexOf(" ") + 1;
    if (mark == 0) {
        *responseCode = -1;
        return NOERROR;
    }
    Int32 last = mark + 3;
    if (last > response.GetLength()) {
        last = response.GetLength();
    }
    mResponseCode = StringUtils::ParseInt32(response.Substring(mark, last));
    if ((last + 1) <= response.GetLength()) {
        mResponseMessage = response.Substring(last + 1);
    }
    *responseCode = mResponseCode;
    return NOERROR;
}
/**
 * Trim leading zeros from IPv4 address strings
 * Our base libraries will interpret that as octel..
 * Must leave non v4 addresses and host names alone.
 * For example, 192.168.000.010 -> 192.168.0.10
 * TODO - fix base libraries and remove this function
 * @param addr a string representing an ip addr
 * @return a string propertly trimmed
 */
String NetworkUtils::TrimV4AddrZeros(
    /* [in] */ const String& addr)
{
    if (addr.IsNull()) {
        return String(NULL);
    }

    AutoPtr<ArrayOf<String> > octets;
    StringUtils::Split(addr, String("\\."), (ArrayOf<String>**)&octets);
    if (octets->GetLength() != 4) {
        return addr;
    }
    StringBuffer buff;
    for (Int32 i = 0; i < 4; i++) {
//        try {
            if ((*octets)[i].GetLength() > 3) {
                return addr;
            }
            buff += (*octets)[i];
//        } catch (NumberFormatException e) {
//            return addr;
//        }
        if (i < 3)
            buff += String(".");
    }
    return buff.ToString();
}
ECode StringEntity::Init(
    /* [in] */ const String& s,
    /* [in] */ const String& _charset)
{
    String charset = _charset;
    if (s.IsNull()) {
        Logger::E("StringEntity", "Source string may not be null");
        return E_ILLEGAL_ARGUMENT_EXCEPTION;
    }
    if (charset.IsNull()) {
        charset = IHTTP::DEFAULT_CONTENT_CHARSET;
    }
    mContent = s.GetBytes();// mContent = s.GetBytes(charset);
    SetContentType(IHTTP::PLAIN_TEXT_TYPE + IHTTP::CHARSET_PARAM + charset);
    return NOERROR;
}
/*static*/
ECode CRingtoneManager::GetActualDefaultRingtoneUri(
    /* [in] */ IContext* context,
    /* [in] */ Int32 type,
    /* [out] */ IUri** result)
{
    VALIDATE_NOT_NULL(result);

    String setting = GetSettingForType(type);
    if (setting == NULL) {
        *result = NULL;
        return NOERROR;
    }
    AutoPtr<IContentResolver> contentResolver;
    context->GetContentResolver((IContentResolver**)&contentResolver);
    String uriString;
    FAIL_RETURN(Settings::System::GetString(contentResolver, setting, &uriString))
    AutoPtr<IUriHelper> uriHelper;
    CUriHelper::AcquireSingleton((IUriHelper**)&uriHelper);
    AutoPtr<IUri> uri;
    uriHelper->Parse(uriString, (IUri**)&uri);

    *result = !uriString.IsNull() ? uri : NULL;
    REFCOUNT_ADD(*result);
    return NOERROR;
}
Example #27
0
ECode CExifInterface::GetAttributeDouble(
    /* [in] */ const String& tag,
    /* [in] */ Double defaultValue,
    /* [out] */ Double* result)
{
    VALIDATE_NOT_NULL(result);
    *result = defaultValue;

    HashMap<String, String>::Iterator it = mAttributes.Find(tag);
    if (it != mAttributes.End()) {
        String value = it->mSecond;
        if (value.IsNull()) {
            return NOERROR;
        }

        Int32 index = value.IndexOf("/");
        if (index == -1) {
            return NOERROR;
        }
        Double denom = StringUtils::ParseDouble(value.Substring(index + 1));
        if (denom == 0) {
            return NOERROR;
        }
        Double num = StringUtils::ParseDouble(value.Substring(0, index));
        *result = num / denom;
    }
    return NOERROR;
}
Example #28
0
ECode CJDBCConnection::SetTransactionIsolation(
    /* [in] */ Int32 level)
{
    Boolean value;
    ECode ec = NOERROR;
    mDb->Is3(&value);

    if (value) {
        String flag;
        if (level == IConnection::TRANSACTION_READ_UNCOMMITTED &&
        mTrmode != IConnection::TRANSACTION_READ_UNCOMMITTED) {
        flag = "on";
        } else if (level == IConnection::TRANSACTION_SERIALIZABLE &&
               mTrmode != IConnection::TRANSACTION_SERIALIZABLE) {
        flag = "off";
        }
        if (!flag.IsNull()) {
            ec = mDb->Exec(String(""), NULL);
            //db.exec("PRAGMA read_uncommitted = " + flag + ";", null);
            mTrmode = level;
        } else {
            return E_SQL_EXCEPTION;
        }
    }
    if (level != mTrmode) {
        return E_SQL_EXCEPTION;
    }

    return ec;
}
Example #29
0
ECode CFastXmlSerializer::EscapeAndAppendString(
    /* [in] */ const String& string)
{
    AutoPtr<ArrayOf<Char32> > charArray = string.GetChars();
    Int32 N = charArray->GetLength();
    Char32 NE = (Char32)ESCAPE_TABLE->GetLength();
    AutoPtr<ArrayOf<String> > escapes = ESCAPE_TABLE;
    Int32 lastPos = 0;
    Int32 pos;
    Char32 c;
    String escape;
    for (pos=0; pos < N; pos++) {
        c = (*charArray)[pos];
        if (c >= NE) continue;
        escape = (*escapes)[c];
        if (escape.IsNull()) continue;
        if (lastPos < pos)
            FAIL_RETURN(Append(string, lastPos, pos-lastPos));
        lastPos = pos + 1;
        FAIL_RETURN(Append(escape));
    }
    if (lastPos < pos)
        FAIL_RETURN(Append(string, lastPos, pos-lastPos));
    return NOERROR;
}
Example #30
0
ECode CVariableOfStruct::GetFieldValueByName(
    /* [in] */ const String& name,
    /* [in] */ void* param,
    /* [in] */ CarDataType type)
{
    if(name.IsNull() || !param) {
        return E_INVALID_ARGUMENT;
    }

    if (!mVarBuf) {
        return E_INVALID_OPERATION;
    }

    Int32 index = 0;
    ECode ec = GetIndexByName(name, &index);
    if (FAILED(ec)) return ec;

    if (type != mStructFieldDesc[index].mType) {
        return E_INVALID_ARGUMENT;
    }

    memcpy(param, mVarBuf + mStructFieldDesc[index].mPos,
            mStructFieldDesc[index].mSize);

    return NOERROR;
}