C++ ArrayOf::GetLength方法代码示例

ECode CActivityOne::OnCreate(
    /* [in] */ IBundle* savedInstanceState)
{
    SetContentView(0x7f030000);

    AutoPtr<IView> view = FindViewById(0x7f050000);
    AutoPtr<INumberPicker> numberPicker = INumberPicker::Probe(view);
    assert(numberPicker != NULL);
    ArrayOf<String>* rangs = ArrayOf<String>::Alloc(10);
    (*rangs)[0] = String("0");
    (*rangs)[1] = String("1");
    (*rangs)[2] = String("2");
    (*rangs)[3] = String("3");
    (*rangs)[4] = String("4");
    (*rangs)[5] = String("5");
    (*rangs)[6] = String("6");
    (*rangs)[7] = String("7");
    (*rangs)[8] = String("8");
    (*rangs)[9] = String("9");
    Int32 len = rangs->GetLength();
    numberPicker->SetRangeEx(0, 9, *rangs);
    return NOERROR;
}

Handle64 StringBlock::NativeCreate(
    /* [in] */ const ArrayOf<Byte>& data,
    /* [in] */ Int32 offset,
    /* [in] */ Int32 size)
{
    Int32 len = data.GetLength();
    if (offset < 0 || offset >= len || size < 0 || size > len || (offset + size) > len) {
        assert(0);
        // jniThrowException(env, "java/lang/IndexOutOfBoundsException", NULL);
        return 0;
    }

    android::ResStringPool* osb = new android::ResStringPool(
            data.GetPayload() + offset, size, TRUE);

    if (osb == NULL || osb->getError() != android::NO_ERROR) {
        assert(0);
        // jniThrowException(env, "java/lang/IllegalArgumentException", NULL);
        return 0;
    }

    return (Handle64)osb;
}

ECode CGeckoSmsManager::OnRecieve(
    IContext *pContext,
    IIntent *pIntent)
{
    // TODO: Try to find the receiver number to be able to populate
    //       SmsMessage.receiver.
    // TODO: Get the id and the date from the stock app saved message.
    //       Using the stock app saved message require us to wait for it to
    //       be saved which can lead to race conditions.
    String action;
    pIntent->GetAction(&action);
    if (action.Equals(GeckoSmsManager_ACTION_SMS_RECEIVED)) {
        AutoPtr<IBundle> bundle;
        pIntent->GetExtras((IBundle**)&bundle);

        if (bundle == NULL) {
          return NOERROR;
        }

        ArrayOf<ArrayOf<Byte>*>* pdus;
        bundle->Get(String("pdus"), (IInterface**)&pdus);

        for (Int32 i = 0; i < pdus->GetLength(); ++i) {
            AutoPtr<ISmsMessage> msg;
            CSmsMessage::CreateFromPdu((*pdus[i], (ISmsMessage**)&msg);
            String smsAddress;
            msg->GetDisplayOriginatingAddress(&smsAddress);
            String messageBody;
            msg->GetDisplayMessageBody(&messageBody);
            // AutoPtr<ISystem> system;
            // Elastos::Core::CSystem::AcquireSingleton((ISystem**)&system);
            // Int64 now;
            // system->GetCurrentTimeMillis(&now);
            GeckoAppShell::NotifySmsReceived(smsAddress, messageBody, GetDisplayMessageBody);
        }
        return NOERROR;
    }

ECode Int64Buffer::Put(
    /* [in] */ const ArrayOf<Int64>& src,
    /* [in] */ Int32 srcOffset,
    /* [in] */ Int32 int64Count)
{
    Int32 arrayLength = src.GetLength();
    if ((srcOffset | int64Count) < 0 || srcOffset > arrayLength || arrayLength - srcOffset < int64Count) {
        // throw new ArrayIndexOutOfBoundsException(arrayLength, offset,
        //         count);
        return E_ARRAY_INDEX_OUT_OF_BOUNDS_EXCEPTION;
    }

    Int32 remaining = 0;
    GetRemaining(&remaining);
    if (int64Count > remaining) {
        // throw new BufferOverflowException();
        return E_BUFFER_OVER_FLOW_EXCEPTION;
    }

    for (Int32 i = srcOffset; i < srcOffset + int64Count; ++i) {
        Put(src[i]);
    }
    return NOERROR;
}

Int64 XmlBlock::NativeCreate(
    /* [in] */ const ArrayOf<Byte>& data,
    /* [in] */ Int32 offset,
    /* [in] */ Int32 size)
{
    Int32 bLen = data.GetLength();
    if (offset < 0 || offset >= bLen || size < 0 || size > bLen || (offset + size) > bLen) {
        // doThrow(env, "java/lang/IndexOutOfBoundsException");
        assert(0);
        return 0;
    }

    android::ResXMLTree* osb = new android::ResXMLTree();
    if (osb) {
        osb->setTo(data.GetPayload() + offset, size, TRUE);
    }
    if (osb == NULL || osb->getError() != android::NO_ERROR) {
        // doThrow(env, "java/lang/IllegalArgumentException");
        assert(0);
        return 0;
    }

    return (Int64)osb;
}

ECode Int64Buffer::Put(
    /* [in] */ const ArrayOf<Int64>& src)
{
    return Put(src, 0, src.GetLength());
}

void UsbHostManager::UsbDeviceAdded(
    /* [in] */ const String& deviceName,
    /* [in] */ Int32 vendorID,
    /* [in] */ Int32 productID,
    /* [in] */ Int32 deviceClass,
    /* [in] */ Int32 deviceSubclass,
    /* [in] */ Int32 deviceProtocol,
    /* [in] */ const ArrayOf<Int32>& interfaceValues,
    /* [in] */ const ArrayOf<Int32>& endpointValues)
{
    if (IsBlackListed(deviceName) || IsBlackListed(deviceClass, deviceSubclass, deviceProtocol)) {
        return;
    }

    AutoLock lock(mLock);

    HashMap< String, AutoPtr<IUsbDevice> >::Iterator it = mDevices.Find(deviceName);
    if (it != mDevices.End() && it->mSecond != NULL) {
        Slogger::W(UsbHostManager::TAG, "device already on mDevices list: %s", (const char*)deviceName);
        return;
    }

    Int32 numInterfaces = interfaceValues.GetLength() / 5;
    AutoPtr< ArrayOf<IParcelable*> > interfaces = ArrayOf<IParcelable*>::Alloc(numInterfaces);
    // try {
    // repackage interfaceValues as an array of UsbInterface
    Int32 intf, endp, ival = 0, eval = 0;
    for (intf = 0; intf < numInterfaces; intf++) {
        Int32 interfaceId = interfaceValues[ival++];
        Int32 interfaceClass = interfaceValues[ival++];
        Int32 interfaceSubclass = interfaceValues[ival++];
        Int32 interfaceProtocol = interfaceValues[ival++];
        Int32 numEndpoints = interfaceValues[ival++];

        AutoPtr<ArrayOf<IParcelable*> > endpoints = ArrayOf<IParcelable*>::Alloc(numEndpoints);
        for (endp = 0; endp < numEndpoints; endp++) {
            Int32 address = endpointValues[eval++];
            Int32 attributes = endpointValues[eval++];
            Int32 maxPacketSize = endpointValues[eval++];
            Int32 interval = endpointValues[eval++];

            AutoPtr<IUsbEndpoint> tempEndpoint;
            ECode ec = CUsbEndpoint::New(address, attributes, maxPacketSize, interval, (IUsbEndpoint**)&tempEndpoint);
            if (FAILED(ec)) {
                Slogger::E(UsbHostManager::TAG, "error parsing USB descriptors 0x%08x", ec);
                return;
            }
            AutoPtr<IParcelable> tmpParcelable = IParcelable::Probe(tempEndpoint);
            endpoints->Set(endp, tmpParcelable);
        }

        // don't allow if any interfaces are blacklisted
        if (IsBlackListed(interfaceClass, interfaceSubclass, interfaceProtocol)) {
            return;
        }

        AutoPtr<IUsbInterface> tempInterface;
        ECode ec = CUsbInterface::New(interfaceId, interfaceClass, interfaceSubclass, interfaceProtocol, *endpoints, (IUsbInterface**)&tempInterface);
        if (FAILED(ec)) {
            Slogger::E(UsbHostManager::TAG, "error parsing USB descriptors 0x%08x", ec);
            return;
        }
        AutoPtr<IParcelable> tmpParcelable = IParcelable::Probe(tempInterface);
        interfaces->Set(intf, tmpParcelable);
    }
    // } catch (Exception e) {
    //     // beware of index out of bound exceptions, which might happen if
    //     // a device does not set bNumEndpoints correctly
    //     Slog.e(TAG, "error parsing USB descriptors", e);
    //     return;
    // }

    AutoPtr<IUsbDevice> targetDevice;
    CUsbDevice::New(deviceName, vendorID, productID, deviceClass, deviceSubclass, deviceProtocol, interfaces, (IUsbDevice**)&targetDevice);
    mDevices[deviceName] = targetDevice;
    GetCurrentSettings()->DeviceAttached(targetDevice);
}

/**
 * Resolves an android.resource URI to a {@link Resources} and a resource id.
 *
 * @hide
 */
ECode ContentResolver::GetResourceId(
    /* [in] */ IUri* uri,
    /* [out] */ IOpenResourceIdResult** result)
{
    VALIDATE_NOT_NULL(result);

    String authority;
    FAIL_RETURN(uri->GetAuthority(&authority));

    AutoPtr<IResources> r;
    AutoPtr<ICharSequence> authority2;
    FAIL_RETURN(CStringWrapper::New(authority, (ICharSequence**)&authority2));

    if (TextUtils::IsEmpty(authority2)) {
        // throw new FileNotFoundException("No authority: " + uri);
        return E_FILE_NOT_FOUND_EXCEPTION;
    } else {
        // try {
            // TODO: ALEX need getResourcesForApplication
            // r = mContext.getPackageManager().getResourcesForApplication(authority);
            return E_NOT_IMPLEMENTED;
        // } catch (NameNotFoundException ex) {
        //     throw new FileNotFoundException("No package found for authority: " + uri);
        // }
    }

    ArrayOf<String>* path;
    FAIL_RETURN(uri->GetPathSegments(&path));
    if (path == NULL) {
        // throw new FileNotFoundException("No path: " + uri);
        return E_FILE_NOT_FOUND_EXCEPTION;
    }

    Int32 len = path->GetLength();
    Int32 id;
    if (len == 1) {
        // try {
            id = (*path)[0].ToInt32(10);
        // } catch (NumberFormatException e) {
        //     throw new FileNotFoundException("Single path segment is not a resource ID: " + uri);
        // }
    } else if (len == 2) {
        FAIL_RETURN(r->GetIdentifier((*path)[1], (*path)[0], authority, &id));
    } else {
        // throw new FileNotFoundException("More than two path segments: " + uri);
        return E_FILE_NOT_FOUND_EXCEPTION;
    }
    if (id == 0) {
        // throw new FileNotFoundException("No resource found for: " + uri);
        return E_FILE_NOT_FOUND_EXCEPTION;
    }

    AutoPtr<IOpenResourceIdResult> res;
    FAIL_RETURN(COpenResourceIdResult::New((IOpenResourceIdResult**)&res));

    res->SetResources(r);
    res->SetResourceId(id);

    *result = res;
    res->AddRef();

    return NOERROR;
}

void testStringBuffer()
{
    printf("==== Enter testStringBuffer ====\n");

    printf("\n === Construct === \n");

    StringBuffer sbc(String("Construct from String"));
    String str = sbc.ToString();
    printf(" > Construct:\n%s\n", (const char*)str);

    printf("\n === Append === \n");

    Char32 a = 'A';
    StringBuffer sb;
    ECode ec = sb.ToString(&str);
    printf(">> Get string from emtpy StringBuffer %s, %08x - %08x\n", str.string(), NOERROR, ec);

    sb.AppendCStr(">>Start\n");
    sb.AppendNULL();
    sb.AppendChar('_');
    sb.AppendChar(a);
    sb.AppendChar('_');
    sb.AppendBoolean(TRUE);
    sb.AppendChar('_');
    sb.AppendBoolean(FALSE);
    sb.AppendChar('_');
    sb.AppendInt32(32);
    sb.AppendChar('_');
    sb.AppendInt32(-32);
    sb.AppendChar('_');
    sb.AppendInt64(64);
    sb.AppendChar('_');
    sb.AppendInt64(-64);
    sb.AppendChar('_');
    sb.AppendFloat(10.0f);
    sb.AppendChar('_');
    sb.AppendDouble(101010.1010);
    sb.AppendChar('_');
    sb.AppendString(String("String"));
    sb.AppendCStr("\n<<End");

    str = sb.ToString();
    printf(" > AppendTest:\n%s\n", (const char*)str);


    printf("\n === Index ===\n");
    Int32 index = 0;
    String subStr("32");
    sb.IndexOf(subStr, &index);
    printf(" > IndexOf %s is %d\n", (const char*)subStr, index);

    subStr = String("_NOT_");
    sb.IndexOf(subStr, &index);
    printf(" > IndexOf %s is %d\n", (const char*)subStr, index);

    subStr = String("32");
    sb.LastIndexOf(subStr, &index);
    printf(" > LastIndexOf %s is %d\n", (const char*)subStr, index);

    subStr = String("_NOT_");
    sb.LastIndexOf(subStr, &index);
    printf(" > LastIndexOf %s is %d\n", (const char*)subStr, index);


    printf("\n === Substring ===\n");
    Int32 start = 30, end = 32;
    sb.Substring(start, &subStr);
    printf(" > Substring from %d is : %s\n", start, (const char*)subStr);
    sb.SubstringEx(start, end, &subStr);
    printf(" > Substring from %d to %d is : %s\n", start, end, (const char*)subStr);

    printf("\n === Get ===\n");
    Char32 ch = 0;
    sb.GetChar(start, &ch);
    printf(" > GetChar at %d is : %c\n", start, ch);
    sb.GetLength(&end);
    printf(" > GetLength is : %d\n", end);
    sb.GetByteCount(&end);
    printf(" > GetByteCount is : %d\n", end);
    sb.GetCapacity(&end);
    printf(" > GetCapacity is : %d\n", end);

    printf("\n === Set/Replace/Insert ===\n");
    sb.SetChar(13, 'B');
    sb.ToString(&str);
    printf(" > SetCharAt:\n%s\n", (const char*)str);
    sb.Replace(15, 15 + 4, String("Replace"));
    sb.ToString(&str);
    printf(" > Replace:\n%s\n", (const char*)str);
    sb.InsertString(15, String("Insert_"));
    sb.ToString(&str);
    printf(" > InsertString:\n%s\n", (const char*)str);
    sb.InsertString(0, String("HeadInsert_"));
    sb.ToString(&str);
    printf(" > InsertString in head:\n%s\n", (const char*)str);
    sb.InsertChar(19, '_');
    sb.ToString(&str);
    printf(" > InsertChar:\n%s\n", (const char*)str);
    sb.InsertBoolean(19, TRUE);
    sb.ToString(&str);
//.........这里部分代码省略.........

ECode CSyncManager::ScheduleSync(
/* [in] */IAccount* requestedAccount,
/* [in] */String* requestedAuthority,
/* [in] */IBundle* extras,
/* [in] */Int64 delay,
/* [in] */Boolean onlyThoseWithUnkownSyncableState)
{
    Boolean isLoggable = Logger::IsLoggable(CSyncManager::TAG, Logger::VERBOSE);


    Boolean allowBackgroundData = FALSE;
    GetConnectivityManager()->GetBackgroundDataSetting(&allowBackgroundData);

    Boolean backgroundDataUsageAllowed = !mBootCompleted || allowBackgroundData;

    if (extras == NULL) {
        CBundle::New((IBundle**)&extras);
    }

    Boolean expedited = FALSE;
    extras->GetBooleanEx(String(ContentResolver_SYNC_EXTRAS_EXPEDITED), FALSE, &expedited);

    if (expedited) {
        delay = -1; // this means schedule at the front of the queue
    }

    ArrayOf<IAccount*>* accounts;

    if (requestedAccount != NULL) {
//        accounts = new Account[]{requestedAccount};
        accounts = ArrayOf<IAccount*>::Alloc(1);
        (*accounts)[0] = requestedAccount;
    } else {
        // if the accounts aren't configured yet then we can't support an account-less
        // sync request
        accounts = mAccounts;

        if (accounts->GetLength() == 0) {
            if (isLoggable) {
                Logger::V(CSyncManager::TAG, String("scheduleSync: no accounts configured, dropping"));
            }

            return NOERROR;
        }
    }

    /*final */ Boolean uploadOnly = FALSE;
    extras->GetBooleanEx(String(ContentResolver_SYNC_EXTRAS_UPLOAD), FALSE, &uploadOnly);

    /*final*/ Boolean manualSync= FALSE;
    extras->GetBooleanEx(String(ContentResolver_SYNC_EXTRAS_MANUAL), FALSE, &manualSync);

    if (manualSync) {
        extras->PutBoolean(String(ContentResolver_SYNC_EXTRAS_IGNORE_BACKOFF), TRUE);
        extras->PutBoolean(String(ContentResolver_SYNC_EXTRAS_IGNORE_SETTINGS), TRUE);
    }

    /*final*/ Boolean ignoreSettings;
    extras->GetBooleanEx(String(ContentResolver_SYNC_EXTRAS_IGNORE_SETTINGS), FALSE, &ignoreSettings);

    Int32 source = 0;

    if (uploadOnly) {
//        source = SyncStorageEngine::SOURCE_LOCAL;
    } else if (manualSync) {
//        source = SyncStorageEngine::SOURCE_USER;
    } else if (requestedAuthority == NULL) {
//        source = SyncStorageEngine::SOURCE_POLL;
    } else {
        // this isn't strictly server, since arbitrary callers can (and do) request
        // a non-forced two-way sync on a specific url
//        source = SyncStorageEngine::SOURCE_SERVER;
    }

    // Compile a list of authorities that have sync adapters.
    // For each authority sync each account that matches a sync adapter.


//    /*final*/ HashSet<String> syncableAuthorities; // = new HashSet<String>();

    /*
    for (RegisteredServicesCache.ServiceInfo<SyncAdapterType> syncAdapter :
            mSyncAdapters->getAllServices()) {
        syncableAuthorities.Insert(syncAdapter.type.authority);
    }

    // if the url was specified then replace the list of authorities with just this authority
    // or clear it if this authority isn't syncable
    if (requestedAuthority != NULL) {
        Boolean hasSyncAdapter = syncableAuthorities.contains(requestedAuthority);
        syncableAuthorities.clear();
        if (hasSyncAdapter) syncableAuthorities.add(requestedAuthority);
    }

    final boolean masterSyncAutomatically = mSyncStorageEngine.getMasterSyncAutomatically();

    for (String authority : syncableAuthorities) {
        for (Account account : accounts) {
            int isSyncable = mSyncStorageEngine.getIsSyncable(account, authority);
            if (isSyncable == 0) {
//.........这里部分代码省略.........