Example #1
0
ECode BluetoothInputDevice::SendData(
    /* [in] */ IBluetoothDevice* device,
    /* [in] */ const String& report,
    /* [out] */ Boolean* result)
{
    VALIDATE_NOT_NULL(result)
    *result = FALSE;

    if (DBG) {
        String str;
        IObject::Probe(device)->ToString(&str);
        Logger::D(TAG, "sendData(%s), report=%s", str.string(), report.string());
    }

    if (mService != NULL && IsEnabled() && IsValidDevice(device)) {
//        try {
        return mService->SendData(device, report, result);
//        } catch (RemoteException e) {
//            Log.e(TAG, "Stack:" + Log.getStackTraceString(new Throwable()));
//            return false;
//        }
    }
    if (mService == NULL) {
        Logger::W(TAG, "Proxy not attached to service");
    }
    return NOERROR;
}
Example #2
0
ECode SQLiteSession::Prepare(
    /* [in] */ const String& sql,
    /* [in] */ Int32 connectionFlags,
    /* [in] */ ICancellationSignal* cancellationSignal,
    /* [in] */ SQLiteStatementInfo* outStatementInfo)
{
    if (sql.IsNullOrEmpty()) {
        //throw new IllegalArgumentException("sql must not be null.");
        Slogger::E("SQLiteSession", "sql must not be null.");
        return E_ILLEGAL_ARGUMENT_EXCEPTION;
    }

    if (cancellationSignal != NULL) {
        FAIL_RETURN(cancellationSignal->ThrowIfCanceled())
    }

    ECode ec = AcquireConnection(sql, connectionFlags, cancellationSignal); // might throw
    if (FAILED(ec)) {
        Slogger::E("SQLiteSession", "Failed to AcquireConnection %s", sql.string());
        return ec;
    }
    //try {
    ec = mConnection->Prepare(sql, outStatementInfo); // might throw
    if (FAILED(ec)) {
        Slogger::E("SQLiteSession", "Failed to Prepare %s", sql.string());
    }

    //} finally {
    ec = ReleaseConnection(); // might throw
    if (FAILED(ec)) {
        Slogger::E("SQLiteSession", "Failed to ReleaseConnection %s", sql.string());
    }
    //}
    return ec;
}
Example #3
0
ECode Proxy::SetHttpProxySystemProperty(
    /* [in] */ const String& host,
    /* [in] */ const String& port,
    /* [in] */ const String& exclList,
    /* [in] */ IUri* pacFileUrl)
{
    AutoPtr<ISystem> system;
    Elastos::Core::CSystem::AcquireSingleton((ISystem**)&system);

    String tmpExclList(exclList);
    if (!(tmpExclList.IsNull())) {
        tmpExclList = tmpExclList.Replace(',', '|');
    }
    String s;
    if (FALSE)
        Logger::D(TAG, "setHttpProxySystemProperty :%s:%s - %s", host.string(), port.string(), tmpExclList.string());
    if (host != String(NULL)) {
        system->SetProperty(String("http.proxyHost"), host, &s);
        system->SetProperty(String("https.proxyHost"), host, &s);
    }
    else {
        system->ClearProperty(String("http.proxyHost"), &s);
        system->ClearProperty(String("https.proxyHost"), &s);
    }
    if (port != String(NULL)) {
        system->SetProperty(String("http.proxyPort"), port, &s);
        system->SetProperty(String("https.proxyPort"), port, &s);
    }
    else {
        system->ClearProperty(String("http.proxyPort"), &s);
        system->ClearProperty(String("https.proxyPort"), &s);
    }
    if (tmpExclList != String(NULL)) {
        system->SetProperty(String("http.nonProxyHosts"), tmpExclList, &s);
        system->SetProperty(String("https.nonProxyHosts"), tmpExclList, &s);
    } else {
        system->ClearProperty(String("http.nonProxyHosts"), &s);
        system->ClearProperty(String("https.nonProxyHosts"), &s);
    }
    AutoPtr<IUri> empty;
    Uri::GetEMPTY((IUri**)&empty);
    AutoPtr<IProxySelectorHelper> helper;
    Boolean isEquals;
    IObject::Probe(empty)->Equals(pacFileUrl, &isEquals);
    if (!isEquals) {
        AutoPtr<IPacProxySelector> newProxySelector;
        CPacProxySelector::New((IPacProxySelector**)&newProxySelector);
        ProxySelector::SetDefault(IProxySelector::Probe(newProxySelector));
    } else {
        ProxySelector::SetDefault(sDefaultProxySelector);
    }
    return NOERROR;
}
Example #4
0
Boolean FontFamily::NativeAddFont(
    /* [in] */ Int64 familyPtr,
    /* [in] */ const String& path)
{
    if (path.IsNull()) {
        return FALSE;
    }
    SkTypeface* face = SkTypeface::CreateFromFile(path.string());
    if (face == NULL) {
        Logger::E(String("FontFamily"), String("addFont failed to create font %s"), path.string());
        return FALSE;
    }
    android::FontFamily* fontFamily = reinterpret_cast<android::FontFamily*>(familyPtr);
    return addSkTypeface(fontFamily, face);
}
Example #5
0
String::String(String& s)
{
	mLength = s.GetLength();
	mBuffer = new char[mLength+1];
	memset(mBuffer, 0, mLength+1);
	strncpy(mBuffer, s.string(), mLength);
}
ECode CStatusBarManagerService::SetIconVisibility(
    /* [in] */ const String& slot,
    /* [in] */ Boolean visible)
{
    FAIL_RETURN(EnforceStatusBar());
    {
        AutoLock Lock(mIconsLock);
        Int32 index = 0;
        assert(mIcons != NULL);
        mIcons->GetSlotIndex(slot, &index);
        if (index < 0) {
            Slogger::E(TAG, "invalid status bar icon slot: %s", slot.string());
            return E_SECURITY_EXCEPTION;
        }

        AutoPtr<IStatusBarIcon> icon;
        mIcons->GetIcon(index, (IStatusBarIcon**)&icon);
        if (icon == NULL) {
            return E_NULL_POINTER_EXCEPTION;
        }

        Boolean v;
        icon->GetVisible(&v);
        if (v != visible) {
            icon->SetVisible(visible);

            if (mBar != NULL) {
                mBar->SetIcon(index, icon);
            }
        }
    }
    return NOERROR;
}
ECode CStatusBarManagerService::SetIcon(
    /* [in] */ const String& slot,
    /* [in] */ const String& iconPackage,
    /* [in] */ Int32 iconId,
    /* [in] */ Int32 iconLevel,
    /* [in] */ const String& contentDescription)
{
    FAIL_RETURN(EnforceStatusBar());
    {
        AutoLock Lock(mIconsLock);
        Int32 index = 0;
        mIcons->GetSlotIndex(slot, &index);
        if (index < 0) {
            Slogger::E(TAG, "invalid status bar icon slot: %s", slot.string());
            return E_SECURITY_EXCEPTION;
        }

        AutoPtr<IStatusBarIcon> icon;

        AutoPtr<ICharSequence> seq;
        CString::New(contentDescription, (ICharSequence**)&seq);

        CStatusBarIcon::New(iconPackage, UserHandle::OWNER, iconId,
                iconLevel, 0,
                seq, (IStatusBarIcon**)&icon);

        mIcons->SetIcon(index, icon);

        if (mBar != NULL) {
            mBar->SetIcon(index, icon);
        }
    }
    return NOERROR;
}
Example #8
0
void testReadZipFile(IZipFile *pZipFile, const String& entryName)
{
    EnterLeaveLog log("test ReadZipFile");

    AutoPtr<IZipEntry> pEntry;
    ECode ec = pZipFile->GetEntry(entryName, (IZipEntry**)&pEntry);
    if (pEntry == NULL) {
        printf(" >> Cann't Find entry: [%s]!\n", entryName.string());
        return;
    }

    AutoPtr<IInputStream> is;
    Int32 len;
    AutoPtr<ArrayOf<Byte> > buf;

    ec = pZipFile->GetInputStream(pEntry, (IInputStream **) &is);
    if (FAILED(ec)) {
        printf(" >> Cann't Get ZipFile InputStream!\n");
        goto _EXIT_;
    }

    buf = ArrayOf<Byte>::Alloc(1024);
    ec = is->ReadBytesEx(buf, 0, 1024, &len);
    while(SUCCEEDED(ec) && len > 0) {
        String tmpStr((const char*)(buf->GetPayload()), len);
        printf(" >> Read %d bytes: [%s]\n", len, tmpStr.string());
        ec = is->ReadBytesEx(buf, 0, 1024, &len);
    }

_EXIT_:
    if (is != NULL) is->Close();
}
Example #9
0
ECode BluetoothInputDevice::SetPriority(
    /* [in] */ IBluetoothDevice* device,
    /* [in] */ Int32 priority,
    /* [out] */ Boolean* result)
{
    VALIDATE_NOT_NULL(result)
    *result = FALSE;

    if (DBG) {
        String str;
        IObject::Probe(device)->ToString(&str);
        Logger::D(TAG, "setPriority(%s, %d)", str.string(), priority);
    }

    if (mService != NULL && IsEnabled() && IsValidDevice(device)) {
        if (priority != IBluetoothProfile::PRIORITY_OFF && priority != IBluetoothProfile::PRIORITY_ON) {
            return NOERROR;
        }
//        try {
        return mService->SetPriority(device, priority, result);
//        } catch (RemoteException e) {
//            Log.e(TAG, "Stack:" + Log.getStackTraceString(new Throwable()));
//            return false;
//        }
    }
    if (mService == NULL) {
        Logger::W(TAG, "Proxy not attached to service");
    }
    return NOERROR;
}
ECode ProfileManagerService::SetActiveProfileByName(
    /* [in] */ const String& profileName,
    /* [out] */ Boolean* result)
{
    VALIDATE_NOT_NULL(result);
    Boolean flag = FALSE;
    mProfileNames->ContainsKey(StringUtils::ParseCharSequence(profileName).Get(), &flag);
    if (!flag) {
        // Since profileName could not be casted into a UUID, we can call it a string.
        Logger::W(TAG, "Unable to find profile to set active, based on string: %s", profileName.string());
        *result = FALSE;
        return NOERROR;
    }

    if (LOCAL_LOGV) {
        Logger::V(TAG, "setActiveProfile(String) found profile name in mProfileNames.");
    }
    AutoPtr<IInterface> obj;
    mProfileNames->Get(StringUtils::ParseCharSequence(profileName).Get(), (IInterface**)&obj);
    AutoPtr<IUUID> uuid = IUUID::Probe(obj);
    obj = NULL;
    mProfiles->Get(uuid.Get(), (IInterface**)&obj);
    SetActiveProfile(IProfile::Probe(obj), TRUE);
    *result = TRUE;
    return NOERROR;
}
Example #11
0
ECode AnimatedStateListDrawable::ParseItem(
    /* [in] */ /*@NonNull*/ IResources* r,
    /* [in] */ /*@NonNull*/ IXmlPullParser* parser,
    /* [in] */ /*@NonNull*/ IAttributeSet* attrs,
    /* [in] */ /*@Nullable*/ IResourcesTheme* theme,
    /* [out] */ Int32* result) /*throws XmlPullParserException, IOException*/
{
    VALIDATE_NOT_NULL(result);
    Int32 drawableRes = 0;
    Int32 keyframeId = 0;

    Int32 j = 0;
    Int32 numAttrs = 0;
    attrs->GetAttributeCount(&numAttrs);
    AutoPtr<ArrayOf<Int32> > states = ArrayOf<Int32>::Alloc(numAttrs);
    for (Int32 i = 0; i < numAttrs; i++) {
        Int32 stateResId = 0;
        attrs->GetAttributeNameResource(i, &stateResId);
        switch (stateResId) {
            case 0:
                break;
            case R::attr::id:
                attrs->GetAttributeResourceValue(i, 0, &keyframeId);
                break;
            case R::attr::drawable:
                attrs->GetAttributeResourceValue(i, 0, &drawableRes);
                break;
            default: {
                Boolean hasState = FALSE;
                attrs->GetAttributeBooleanValue(i, FALSE, &hasState);
                (*states)[j++] = hasState ? stateResId : -stateResId;
                break;
            }
        }
    }

    AutoPtr<ArrayOf<Int32> > temp = StateSet::TrimStateSet(states, j);
    states = temp;

    AutoPtr<IDrawable> dr;
    if (drawableRes != 0) {
        r->GetDrawable(drawableRes, theme, (IDrawable**)&dr);
    }
    else {
        Int32 type = 0;
        while ((parser->Next(&type), type) == IXmlPullParser::TEXT) {
        }
        if (type != IXmlPullParser::START_TAG) {
            String str;
            parser->GetPositionDescription(&str);
            Logger::E(LOGTAG, "XmlPullParserException: %s: <item> tag requires a 'drawable' attribute or "
                "child tag defining a drawable", str.string());
            return E_XML_PULL_PARSER_EXCEPTION;
        }
        FAIL_RETURN(Drawable::CreateFromXmlInner(r, parser, attrs, theme, (IDrawable**)&dr));
    }

    *result = mState->AddStateSet(states, dr, keyframeId);
    return NOERROR;
}
Example #12
0
ECode BluetoothInputDevice::GetConnectionState(
    /* [in] */ IBluetoothDevice* device,
    /* [out] */ Int32* state)
{
    VALIDATE_NOT_NULL(state)
    *state = IBluetoothProfile::STATE_DISCONNECTED;

    if (VDBG) {
        String str;
        IObject::Probe(device)->ToString(&str);
        Logger::D(TAG, "getState(%s)", str.string());
    }

    if (mService != NULL && IsEnabled() && IsValidDevice(device)) {
//        try {
        return mService->GetConnectionState(device, state);
//        } catch (RemoteException e) {
//            Log.e(TAG, "Stack:" + Log.getStackTraceString(new Throwable()));
//            return BluetoothProfile.STATE_DISCONNECTED;
//        }
    }
    if (mService == NULL) {
        Logger::W(TAG, "Proxy not attached to service");
    }
    return NOERROR;
}
Example #13
0
/**
 * Send Set_Idle_Time command to the connected HID input device.
 *
 * <p>Requires {@link android.Manifest.permission#BLUETOOTH_ADMIN} permission.
 *
 * @param device Remote Bluetooth Device
 * @param idleTime Idle time to be set on HID Device
 * @return false on immediate error,
 *               true otherwise
 * @hide
 */
ECode BluetoothInputDevice::SetIdleTime(
    /* [in] */ IBluetoothDevice* device,
    /* [in] */ Byte idleTime,
    /* [out] */ Boolean* result)
{
    if (device != NULL && DBG) {
        String deviceStr;
        IObject::Probe(device)->ToString(&deviceStr);
        Logger::D(TAG, "SetIdleTime(%s), idleTime = %d", deviceStr.string(), idleTime);
    }
    if (mService != NULL && IsEnabled() && IsValidDevice(device)) {
        // try {
            if (FAILED(mService->SetIdleTime(device, idleTime, result))) {
                Logger::E(TAG, "GetIdleTime: Remote invoke error: mService->SetIdleTime");
                *result = FALSE;
                return NOERROR;
            }
        // } catch (RemoteException e) {
            // return false;
        // }
    }
    if (mService == NULL)
        Logger::W(TAG, "Proxy not attached to service");
    *result = FALSE;
    return NOERROR;
}
Example #14
0
ECode BluetoothInputDevice::GetReport(
    /* [in] */ IBluetoothDevice* device,
    /* [in] */ Byte reportType,
    /* [in] */ Byte reportId,
    /* [in] */ Int32 bufferSize,
    /* [out] */ Boolean* result)
{
    VALIDATE_NOT_NULL(result)
    *result = FALSE;

    if (VDBG) {
        String str;
        IObject::Probe(device)->ToString(&str);
        Logger::D(TAG, "getReport(%s), reportType=%d reportId=%d bufferSize=%d", str.string(), reportType, reportId, bufferSize);
    }
    if (mService != NULL && IsEnabled() && IsValidDevice(device)) {
//        try {
        return mService->GetReport(device, reportType, reportId, bufferSize, result);
//        } catch (RemoteException e) {
//            Log.e(TAG, "Stack:" + Log.getStackTraceString(new Throwable()));
//            return false;
//        }
    }
    if (mService == NULL) {
        Logger::W(TAG, "Proxy not attached to service");
    }
    return NOERROR;
}
Example #15
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 #16
0
ECode Request::Reset()
{
    /* clear content-length header */
    // TODO: Waiting for IBasicHttpRequest
    assert(0);
    // mHttpRequest->RemoveHeaders(CONTENT_LENGTH_HEADER);

    if (mBodyProvider != NULL) {
        if(FAILED(mBodyProvider->Reset())) {
            if (HttpLog::LOGV) {
                String uri;
                GetUri(&uri);
                HttpLog::V("failed to reset body provider %s", uri.string());
            }
        }

        SetBodyProvider(mBodyProvider, mBodyLength);
    }

    if (mReceivedBytes > 0) {
        // reset the fail count as we continue the request
        mFailCount = 0;
        // set the "Range" header to indicate that the retry will continue
        // instead of restarting the request
        HttpLog::V(String("*** Request.reset() to range:") + StringUtils::ToString(mReceivedBytes));
        // TODO: Waiting for IBasicHttpRequest
        assert(0);
        // mHttpRequest->SetHeader(String("Range"), String("bytes=") + StringUtils::ToString(mReceivedBytes) + String("-"));
    }

    return NOERROR;
}
Example #17
0
void FieldEditor::field(const String& s)
{
    String old(impl_->editor_->value());
    impl_->editor_->region(0, 0, 0, old.length());
    impl_->editor_->cut();
    impl_->editor_->paste(s.string(), s.length());
}
Example #18
0
ECode BluetoothInputDevice::GetPriority(
    /* [in] */ IBluetoothDevice* device,
    /* [out] */ Int32* priority)
{
    VALIDATE_NOT_NULL(priority)
    *priority = IBluetoothProfile::PRIORITY_OFF;

    if (VDBG) {
        String str;
        IObject::Probe(device)->ToString(&str);
        Logger::D(TAG, "getPriority(%s)", str.string());
    }

    if (mService != NULL && IsEnabled() && IsValidDevice(device)) {
//        try {
        return mService->GetPriority(device, priority);
//        } catch (RemoteException e) {
//            Log.e(TAG, "Stack:" + Log.getStackTraceString(new Throwable()));
//            return BluetoothProfile.PRIORITY_OFF;
//        }
    }
    if (mService == NULL) {
        Logger::W(TAG, "Proxy not attached to service");
    }
    return NOERROR;
}
ECode CRestoreObserver::OnUpdate(
    /* [in] */ Int32 nowBeingRestored,
    /* [in] */ const String& curentPackage)
{
    // TODO: Add your code here
    printf("Backup RestoreObserver::OnUpdate[%d-- %s]\n", nowBeingRestored, curentPackage.string());
    return NOERROR;
}
ECode CObjInfoList:: RemoveClsModule(
    /* [in] */ const String& path)
{
    if (path.IsNull()) {
        return E_INVALID_ARGUMENT;
    }
    mClsModule.Remove((PVoid)path.string());
    return NOERROR;
}
Example #21
0
Int32 FileBackupHelperBase::NativeWriteFile(
    /* [in] */ const String& fileName,
    /* [in] */ Int32 backupReader)
{
    android::RestoreHelperBase* restore = (android::RestoreHelperBase*)mPtr;
    android::BackupDataReader* reader = (android::BackupDataReader*)backupReader;
    char const* filename = fileName.string();
    int err = restore->WriteFile(android::String8(filename), reader);
    return err;
}
Example #22
0
ECode CInputBindResult::ToString(
    /* [out] */ String* str)
{
    String strMethod;
    IObject::Probe(mMethod)->ToString(&strMethod);
    *str = NULL;
    str->AppendFormat("InputBindResult{%s %s sequence:%d userActionNotificationSequenceNumber:%d}",
        strMethod.string(), mId.string(), mSequence, mUserActionNotificationSequenceNumber);
    return NOERROR;
}
Example #23
0
ECode EcoFile::OpenEcoFile(
    /* [in] */ const String& sourceName,
    /* [out] */ IModuleInfo** ecoModule)
{
    String fileName = sourceName;
    Int32 start = fileName.LastIndexOf("/");
    Int32 end = fileName.LastIndexOf("-");
    fileName = fileName.Substring(start >= 0 ? start + 1 : 0, end >= 0 ? end : fileName.GetLength() - 4)  + String(".eco");
    String path = String("/data/elastos/") + fileName;
    AutoPtr<IModuleInfo> moduleInfo;
    if (FAILED(CReflector::AcquireModuleInfo(path.string(), (IModuleInfo**)&moduleInfo))) {
        *ecoModule = NULL;
        Slogger::E(TAG, "OpenEcoFile: Cann't Find the Instrumentation path is %s", path.string());
        return E_RUNTIME_EXCEPTION;
    }
    *ecoModule = moduleInfo;
    REFCOUNT_ADD(*ecoModule);
    return NOERROR;
}
Example #24
0
ECode ActivityInfo::ToString(
    /* [out] */ String* str)
{
    VALIDATE_NOT_NULL(str)
    Int32 hashCode;
    GetHashCode(&hashCode);
    String pii;
    PackageItemInfo::ToString(&pii);
    str->AppendFormat("ActivityInfo{0x%08x %s}", hashCode, pii.string());
    return NOERROR;
}
void NetInitiatedActivity::HandleNIVerify(
    /* [in] */ IIntent* intent)
{
    Int32 notifId;
    intent->GetInt32Extra(IGpsNetInitiatedHandler::NI_INTENT_KEY_NOTIF_ID, -1, &notifId);
    mNotificationId = notifId;

    String action;
    intent->GetAction(&action);
    if (DEBUG) Slogger::D(TAG, "handleNIVerify action: %s", action.string());
}
Example #26
0
ECode CGpio::NativeWriteGpio(
    /* [in] */ const String& path,
    /* [in] */ const String& value,
    /* [out] */ Int32* result)
{
    VALIDATE_NOT_NULL(result);

    if (mGpioService == NULL) {
        Slogger::E(TAG, "gpio service has not start!");
        return E_NULL_POINTER_EXCEPTION;
    }
    if (path == NULL) {
        *result = -1;
    } else {
        const char *chars = path.string();
        const char *valueStr = value.string();
        *result = mGpioService->writeData(valueStr, strlen(valueStr), chars);
    }
    return NOERROR;
}
Example #27
0
Boolean FontFamily::NativeAddFontWeightStyle(
    /* [in] */ Int64 familyPtr,
    /* [in] */ const String& path,
    /* [in] */ Int32 weight,
    /* [in] */ Boolean isItalic)
{
    if (path.IsNull()) {
        return FALSE;
    }
    SkTypeface* face = SkTypeface::CreateFromFile(path.string());
    if (face == NULL) {
        Logger::E(String("FontFamily"), String("addFont failed to create font %s"), path.string());
        return FALSE;
    }
    android::FontFamily* fontFamily = reinterpret_cast<android::FontFamily*>(familyPtr);
    MinikinFont* minikinFont = new MinikinFontSkia(face);
    fontFamily->addFont(minikinFont, android::FontStyle(weight / 100, isItalic));
    minikinFont->Unref();
    return TRUE;
}
Example #28
0
Int64 FontFamily::NativeCreateFamily(
    /* [in] */ const String& lang,
    /* [in] */ Int32 variant)
{
    android::FontLanguage fontLanguage;
    if (!lang.IsNull()) {
        fontLanguage = android::FontLanguage(lang.string(), lang.GetLength());
    }
    android::FontFamily* family = new android::FontFamily(fontLanguage, variant);
    return reinterpret_cast<Int64>(family);
}
Example #29
0
void CRemoteDisplay::StartListening(
    /* [in] */ const String& iface)
{
    mPtr = NativeListen(iface);
    if (mPtr == 0) {
        Logger::E("RemoteDisplay", "Could not start listening for remote display connection on \"%s\"",
            iface.string());
    }

    mGuard->Open(String("CRemoteDisplay::Dispose"));
}
Example #30
0
void Observer::ObjectDiscovered(
    /* [in] */ const String& busname,
    /* [in] */ const String& path,
    /* [in] */ ArrayOf<String>* interfaces,
    /* [in] */ Int32 sessionId)
{
    if (DEBUG) {
		Logger::I(TAG, " >> ObjectDiscovered: busname: %s, path: %s, sessionId: %08x", busname.string(), path.string(), sessionId);
		for (Int32 i = 0; i < interfaces->GetLength(); ++i) {
		    Logger::I(TAG, "     > interface %d: %s", i, (*interfaces)[i].string());
		}
	}

    List<AutoPtr<IInterfaceInfo> > intfList;

    HashMap<String, AutoPtr<IInterfaceInfo> >::Iterator mit;
    for (Int32 i = 0; i < interfaces->GetLength(); ++i) {
        mit = mInterfaceMap.Find((*interfaces)[i]);
        if (mit != mInterfaceMap.End()) {
            intfList.PushBack(mit->mSecond);
        }
    }

    //TODO figure out what to do with secure bus objects
    Int32 i = 0;
    AutoPtr<ArrayOf<IInterfaceInfo*> > infos = ArrayOf<IInterfaceInfo*>::Alloc(intfList.GetSize());
    List<AutoPtr<IInterfaceInfo> >::Iterator lit;
    for (lit = intfList.Begin(); lit != intfList.End(); ++lit) {
        infos->Set(i++, *lit);
    }
    AutoPtr<IProxyBusObject> proxy;
    mBus->GetProxyBusObject(busname, path, sessionId, infos, (IProxyBusObject**)&proxy);

    AutoPtr< List<AutoPtr<WrappedListener> > > copiedListeners;
    {
        AutoLock lock(this);
        AutoPtr<ObjectId> oid = new ObjectId(busname, path);
        mProxies->Put(TO_IINTERFACE(oid), proxy);
        copiedListeners = new List<AutoPtr<WrappedListener> >(mListeners);
    }

    /* we do the listener invocation outside of the critical region to avoid
     * lock ordering issues */
    List<AutoPtr<WrappedListener> >::Iterator wit;
    for (wit = copiedListeners->Begin(); wit != copiedListeners->End(); ++wit) {
        if ((*wit)->mEnabled) {
            // protect against exceptions in listener code.
            if (DEBUG) {
				Logger::I(TAG, " >> %s ObjectDiscovered: %s", TO_CSTR((*wit)->mListener), TO_CSTR(proxy));
			}
            (*wit)->mListener->ObjectDiscovered(proxy);
        }
    }
}