void AwCookieManager::NativeSetCookie( /* [in] */ const String& url, /* [in] */ const String& value, /* [in] */ CookieCallback* callback) { Elastos_AwCookieManager_nativeSetCookie(TO_IINTERFACE(this), url, value, TO_IINTERFACE(callback)); }
ECode BluetoothLeScanner::StartTruncatedScan( /* [in] */ IList* truncatedFilters, /* [in] */ IScanSettings* settings, /* [in] */ IScanCallback* callback) { Int32 filterSize; truncatedFilters->GetSize(&filterSize); //List<ScanFilter> scanFilters = new ArrayList<ScanFilter>(filterSize); AutoPtr<IList> scanFilters; CArrayList::New((IList**)&scanFilters); //List<List<ResultStorageDescriptor>> scanStorages = // new ArrayList<List<ResultStorageDescriptor>>(filterSize); AutoPtr<IList> scanStorages; CArrayList::New((IList**)&scanStorages); //for (TruncatedFilter filter : truncatedFilters) { Int32 size; truncatedFilters->GetSize(&size); for (Int32 i = 0; i < size; ++i) { AutoPtr<IInterface> obj; truncatedFilters->Get(i, (IInterface**)&obj); ITruncatedFilter* filter = ITruncatedFilter::Probe(obj); AutoPtr<IScanFilter> scanFilter; filter->GetFilter((IScanFilter**)&scanFilter); scanFilters->Add(TO_IINTERFACE(scanFilters)); AutoPtr<IList> list; filter->GetStorageDescriptors((IList**)&list); scanStorages->Add(TO_IINTERFACE(list)); } StartScan(scanFilters, settings, callback, scanStorages); return NOERROR; }
ECode BluetoothLeScanner::BleScanCallbackWrapper::StartRegisteration() { { AutoLock lock(sLock); // Scan stopped. if (mClientIf == -1) return NOERROR; //try { AutoPtr<IUUIDHelper> uuidHelper; CUUIDHelper::AcquireSingleton((IUUIDHelper**)&uuidHelper); AutoPtr<IUUID> uuid; uuidHelper->RandomUUID((IUUID**)&uuid); AutoPtr<IParcelUuid> parcelUuid; CParcelUuid::New(uuid, (IParcelUuid**)&parcelUuid); ECode ec1 = mBluetoothGatt->RegisterClient(parcelUuid, this); ECode ec2 = Wait(REGISTRATION_CALLBACK_TIMEOUT_MILLIS); //} catch (InterruptedException | RemoteException e) { if (FAILED(ec1) || FAILED(ec2)) {//need check, maybe only the specific exception //Log.e(TAG, "application registeration exception", e); Logger::E(TAG, "application registeration exception"); mOwner->PostCallbackError(mScanCallback, IScanCallback::SCAN_FAILED_INTERNAL_ERROR); } //} if (mClientIf > 0) { mOwner->mLeScanClients->Put(TO_IINTERFACE(mScanCallback), TO_IINTERFACE(this)); } else { mOwner->PostCallbackError(mScanCallback, IScanCallback::SCAN_FAILED_APPLICATION_REGISTRATION_FAILED); } } return NOERROR; }
ECode AdvertiseData::Builder::AddServiceData( /* [in] */ IParcelUuid* serviceDataUuid, /* [in] */ ArrayOf<Byte>* serviceData) { if (serviceDataUuid == NULL || serviceData == NULL ) { //throw new IllegalArgumentException("serviceDataUuid or serviceDataUuid is null"); Slogger::E("AdvertiseData::Builder::AddServiceData", "serviceDataUuid or serviceDataUuid is null"); return E_ILLEGAL_ARGUMENT_EXCEPTION; } AutoPtr<IArrayOf> sd = CoreUtils::ConvertByteArray(serviceData); mServiceData->Put(TO_IINTERFACE(serviceDataUuid), TO_IINTERFACE(sd)); //return this; return NOERROR; }
void MediaPlayerListener::NativeOnVideoSizeChanged( /* [in] */ Handle64 nativeMediaPlayerListener, /* [in] */ Int32 width, /* [in] */ Int32 height) { Elastos_MediaPlayerListener_nativeOnVideoSizeChanged(TO_IINTERFACE(this), nativeMediaPlayerListener, width, height); }
Boolean BluetoothLeUtils::Equals( /* [in] */ IMap* map, /* [in] */ IMap* otherMap) { Boolean result; map->Equals(TO_IINTERFACE(otherMap), &result); return result; // if (map == otherMap) { // return TRUE; // } // if (map == NULL|| otherMap == NULL) { // return FALSE; // } // Int32 size1, size2; // map->GetSize(&size1); // otherMap->GetSize(&size2); // if (size1 != size2) { // return FALSE; // } // //Set<T> keys = map.keySet(); // AutoPtr<ISet> keyset1, keyset2; // map->GetKeySet((ISet**)&keyset1); // otherMap->GetKeySet((ISet**)&keyset2); // Boolean equals; // keyset1->Equals(TO_IINTERFACE(keyset2), &equals); // if (!equals) { // return FALSE; // } // for (T key : keys) { // if (!Objects.deepEquals(map.get(key), otherMap.get(key))) { // return false; // } // } // return TRUE; }
//@CalledByNative return IMediaPlayerListener AutoPtr<IInterface> MediaPlayerListener::Create( /* [in] */ Handle64 nativeMediaPlayerListener, /* [in] */ IContext* context, /* [in] */ MediaPlayerBridge* mediaPlayerBridge) { AutoPtr<MediaPlayerListener> listener = new MediaPlayerListener(nativeMediaPlayerListener, context); mediaPlayerBridge->SetOnBufferingUpdateListener(listener); mediaPlayerBridge->SetOnCompletionListener(listener); mediaPlayerBridge->SetOnErrorListener(listener); mediaPlayerBridge->SetOnPreparedListener(listener); mediaPlayerBridge->SetOnSeekCompleteListener(listener); mediaPlayerBridge->SetOnVideoSizeChangedListener(listener); AutoPtr<IAudioManager> am; AutoPtr<IInterface> obj; context->GetSystemService(IContext::AUDIO_SERVICE, (IInterface**)&obj); am = IAudioManager::Probe(obj); Int32 result; am->RequestAudioFocus( listener, IAudioManager::STREAM_MUSIC, // Request permanent focus. IAudioManager::AUDIOFOCUS_GAIN_TRANSIENT_MAY_DUCK, &result); AutoPtr<IInterface> iListener = TO_IINTERFACE(listener); return iListener; }
ECode WindowElastos::NativeOnVSync( /* [in] */ Handle64 nativeWindowElastos, /* [in] */ Int64 vsyncTimeMicros) { Elastos_WindowAndroid_nativeOnVSync(TO_IINTERFACE(this), (Handle64)nativeWindowElastos, vsyncTimeMicros); return NOERROR; }
ECode AdvertiseData::GetHashCode( /* [out] */ Int32* hashCode) { VALIDATE_NOT_NULL(hashCode); //return Objects.hash(mServiceUuids, mManufacturerSpecificData, mServiceData, mIncludeDeviceName, mIncludeTxPowerLevel); AutoPtr<IBoolean> idnBoolean = CoreUtils::Convert(mIncludeDeviceName); AutoPtr<IBoolean> itplBoolean = CoreUtils::Convert(mIncludeTxPowerLevel); AutoPtr<ArrayOf<IInterface*> > array = ArrayOf<IInterface*>::Alloc(5); array->Set(0, TO_IINTERFACE(mServiceUuids)); array->Set(1, TO_IINTERFACE(mManufacturerSpecificData)); array->Set(2, TO_IINTERFACE(mServiceData)); array->Set(3, TO_IINTERFACE(idnBoolean)); array->Set(4, TO_IINTERFACE(itplBoolean)); *hashCode = Arrays::GetHashCode(array); return NOERROR; }
ECode AdvertiseData::Builder::AddServiceUuid( /* [in] */ IParcelUuid* serviceUuid) { if (serviceUuid == NULL) { //throw new IllegalArgumentException("serivceUuids are null"); Slogger::E("AdvertiseData::Builder::AddServiceUuid", "serivceUuids are null"); return E_ILLEGAL_ARGUMENT_EXCEPTION; } mServiceUuids->Add(TO_IINTERFACE(serviceUuid)); //return this; return NOERROR; }
ECode BluetoothLeScanner::StopScan( /* [in] */ IScanCallback* callback) { BluetoothLeUtils::CheckAdapterStateOn(mBluetoothAdapter); { AutoLock lock(mLeScanClients); AutoPtr<IInterface> value; mLeScanClients->Remove(TO_IINTERFACE(callback), (IInterface**)&value); AutoPtr<BleScanCallbackWrapper> wrapper = (BleScanCallbackWrapper*)(IIBluetoothGattCallback::Probe(value)); if (wrapper == NULL) { if (DBG) Logger::D(TAG, "could not find callback wrapper"); return NOERROR; } wrapper->StopLeScan(); } return NOERROR; }
ECode AdvertiseData::Builder::AddManufacturerData( /* [in] */ Int32 manufacturerId, /* [in] */ ArrayOf<Byte>* manufacturerSpecificData) { if (manufacturerId < 0) { //throw new IllegalArgumentException("invalid manufacturerId - " + manufacturerId); Slogger::E("AdvertiseData::Builder::AddManufacturerData", "invalid manufacturerId - %d", manufacturerId); return E_ILLEGAL_ARGUMENT_EXCEPTION; } if (manufacturerSpecificData == NULL) { //throw new IllegalArgumentException("manufacturerSpecificData is null"); Slogger::E("AdvertiseData::Builder::AddManufacturerData", "manufacturerSpecificData is null"); return E_ILLEGAL_ARGUMENT_EXCEPTION; } AutoPtr<IArrayOf> msd = CoreUtils::ConvertByteArray(manufacturerSpecificData); mManufacturerSpecificData->Put(manufacturerId, TO_IINTERFACE(msd)); //return this; return NOERROR; }
Boolean WindowElastos::RemoveIntentCallback( /* [in] */ IntentCallback* callback) { // ==================before translated====================== // int requestCode = mOutstandingIntents.indexOfValue(callback); // if (requestCode < 0) return false; // mOutstandingIntents.remove(requestCode); // mIntentErrors.remove(requestCode); // return true; IInterface* interfaceTmp = TO_IINTERFACE(callback); Int32 requestCode = 0; mOutstandingIntents->IndexOfValue(interfaceTmp, &requestCode); if (requestCode < 0) return FALSE; mOutstandingIntents->Remove(requestCode); AutoPtr<IInteger32> requestCodeTmp; CInteger32::New(requestCode, (IInteger32**)&requestCodeTmp); mIntentErrors->Remove(requestCodeTmp); return TRUE; }
ECode BluetoothLeScanner::FlushPendingScanResults( /* [in] */ IScanCallback* callback) { BluetoothLeUtils::CheckAdapterStateOn(mBluetoothAdapter); if (callback == NULL) { //throw new IllegalArgumentException("callback cannot be null!"); Logger::E("BluetoothLeScanner::FlushPendingScanResults", "callback cannot be null"); return E_ILLEGAL_ARGUMENT_EXCEPTION; } { AutoLock lock(mLeScanClients); AutoPtr<IInterface> value; mLeScanClients->Get(TO_IINTERFACE(callback), (IInterface**)&value); AutoPtr<BleScanCallbackWrapper> wrapper = (BleScanCallbackWrapper*)(IIBluetoothGattCallback::Probe(value)); if (wrapper == NULL) { return NOERROR; } wrapper->FlushPendingBatchResults(); } return NOERROR; }
ECode BluetoothLeScanner::StartScan( /* [in] */ IList* filters, /* [in] */ IScanSettings* settings, /* [in] */ IScanCallback* callback, /* [in] */ IList* resultStorages) { BluetoothLeUtils::CheckAdapterStateOn(mBluetoothAdapter); if (settings == NULL|| callback == NULL) { //throw new IllegalArgumentException("settings or callback is null"); Logger::E("BluetoothLeScanner::StartScan", "settings or callback is null"); return E_ILLEGAL_ARGUMENT_EXCEPTION; } { AutoLock lock(mLeScanClients); Boolean containsKey; if (mLeScanClients->ContainsKey(TO_IINTERFACE(callback), &containsKey), containsKey) { PostCallbackError(callback, IScanCallback::SCAN_FAILED_ALREADY_STARTED); return NOERROR; } AutoPtr<IIBluetoothGatt> gatt; //try { mBluetoothManager->GetBluetoothGatt((IIBluetoothGatt**)&gatt); //} catch (RemoteException e) { // gatt = NULL; //} if (gatt == NULL) { PostCallbackError(callback, IScanCallback::SCAN_FAILED_INTERNAL_ERROR); return NOERROR; } if (!IsSettingsConfigAllowedForScan(settings)) { PostCallbackError(callback, IScanCallback::SCAN_FAILED_FEATURE_UNSUPPORTED); return NOERROR; } AutoPtr<BleScanCallbackWrapper> wrapper = new BleScanCallbackWrapper(gatt, filters, settings, callback, resultStorages, this); wrapper->StartRegisteration(); } return NOERROR; }
ECode CPorterDuffColorFilter::Equals( /* [in] */ IInterface* object, /* [out] */ Boolean* equals) { VALIDATE_NOT_NULL(equals); *equals = TRUE; if (TO_IINTERFACE(this) == IInterface::Probe(object)) { return NOERROR; } ClassID id1, id2; GetClassID(&id1); if (object == NULL || id1 != (IObject::Probe(object)->GetClassID(&id2), id2)) { *equals = FALSE; return NOERROR; } AutoPtr<IPorterDuffColorFilter> other = IPorterDuffColorFilter::Probe(object); if (mColor != ((CPorterDuffColorFilter*)other.Get())->mColor || mMode != ((CPorterDuffColorFilter*)other.Get())->mMode) { *equals = FALSE; return NOERROR; } return NOERROR; }
ECode AdvertiseData::Equals( /* [in] */ IInterface* obj, /* [out] */ Boolean* result) { VALIDATE_NOT_NULL(result); if (TO_IINTERFACE(this) == obj) { return TRUE; } if (obj == NULL || IAdvertiseData::Probe(obj) == NULL/*getClass() != obj.getClass()*/) { return FALSE; } AdvertiseData* other = (AdvertiseData*)(IAdvertiseData::Probe(obj)); //return Objects.equals(mServiceUuids, other.mServiceUuids) && // BluetoothLeUtils.equals(mManufacturerSpecificData, other.mManufacturerSpecificData) && // BluetoothLeUtils.equals(mServiceData, other.mServiceData) && // mIncludeDeviceName == other.mIncludeDeviceName && // mIncludeTxPowerLevel == other.mIncludeTxPowerLevel; *result = Objects::Equals(mServiceUuids, other->mServiceUuids) && BluetoothLeUtils::Equals(mManufacturerSpecificData, other->mManufacturerSpecificData) && BluetoothLeUtils::Equals(mServiceData, other->mServiceData) && mIncludeDeviceName == other->mIncludeDeviceName && mIncludeTxPowerLevel == other->mIncludeTxPowerLevel; return NOERROR; }
void MediaPlayerListener::NativeOnBufferingUpdate( /* [in] */ Handle64 nativeMediaPlayerListener, /* [in] */ Int32 percent) { Elastos_MediaPlayerListener_nativeOnBufferingUpdate(TO_IINTERFACE(this), nativeMediaPlayerListener, percent); }
void AwCookieManager::NativeRemoveAllCookiesSync() { Elastos_AwCookieManager_nativeRemoveAllCookiesSync(TO_IINTERFACE(this)); }
void AwCookieManager::NativeRemoveExpiredCookies() { Elastos_AwCookieManager_nativeRemoveExpiredCookies(TO_IINTERFACE(this)); }
void AwCookieManager::NativeFlushCookieStore() { Elastos_AwCookieManager_nativeFlushCookieStore(TO_IINTERFACE(this)); }
ECode AdvertiseData::WriteToParcel( /* [in] */ IParcel* dest) { VALIDATE_NOT_NULL(dest); //dest.writeList(mServiceUuids); dest->WriteInterfacePtr(TO_IINTERFACE(mServiceUuids.Get())); // mManufacturerSpecificData could not be null. Int32 msdSize; mManufacturerSpecificData->GetSize(&msdSize); dest->WriteInt32(msdSize); for (Int32 i = 0; i < msdSize; ++i) { Int32 keyValue; mManufacturerSpecificData->KeyAt(i, &keyValue); dest->WriteInt32(keyValue); AutoPtr<IInterface> value; mManufacturerSpecificData->ValueAt(i, (IInterface**)&value); AutoPtr<IArrayOf> data = IArrayOf::Probe(value); if (data == NULL) { dest->WriteInt32(0); } else { dest->WriteInt32(1); Int32 length; data->GetLength(&length); dest->WriteInt32(length); AutoPtr<ArrayOf<Byte> > arrayByte = ArrayOf<Byte>::Alloc(length); for (Int32 i = 0; i < length; ++i) { AutoPtr<IInterface> obj; data->Get(i, (IInterface**)&obj); IByte* iByte = IByte::Probe(obj); Byte bValue; iByte->GetValue(&bValue); arrayByte->Set(i, bValue); } dest->WriteArrayOf((Handle32)(arrayByte.Get())); } } Int32 mapSize; mServiceData->GetSize(&mapSize); dest->WriteInt32(mapSize); AutoPtr<ISet> keySet; mServiceData->GetKeySet((ISet**)&keySet); AutoPtr<ArrayOf<IInterface*> > keyArray; keySet->ToArray((ArrayOf<IInterface*>**)&keyArray); for (Int32 i = 0; i < keyArray->GetLength(); ++i) { //AutoPtr<IParcelUuid> uuid = IParcelUuid::Probe((*keyArray)[i]); AutoPtr<IInterface> uuid = (*keyArray)[i]; //dest.writeParcelable(uuid, flags); dest->WriteInterfacePtr(uuid); AutoPtr<IInterface> value; mServiceData->Get(uuid, (IInterface**)&value); AutoPtr<IArrayOf> data = IArrayOf::Probe(value); if (data == NULL) { dest->WriteInt32(0); } else { dest->WriteInt32(1); Int32 length; data->GetLength(&length); dest->WriteInt32(length); AutoPtr<ArrayOf<Byte> > arrayByte = ArrayOf<Byte>::Alloc(length); for (Int32 i = 0; i < length; ++i) { AutoPtr<IInterface> obj; data->Get(i, (IInterface**)&obj); IByte* iByte = IByte::Probe(obj); Byte bValue; iByte->GetValue(&bValue); arrayByte->Set(i, bValue); } dest->WriteArrayOf((Handle32)(arrayByte.Get())); } } Boolean bPL = FALSE, bDN = FALSE; dest->WriteByte((Byte) ((GetIncludeTxPowerLevel(&bPL), bPL) ? 1 : 0)); dest->WriteByte((Byte) ((GetIncludeDeviceName(&bDN), bDN) ? 1 : 0)); return NOERROR; }
Boolean AwCookieManager::NativeHasCookies() { return Elastos_AwCookieManager_nativeHasCookies(TO_IINTERFACE(this)); }
Boolean AwCookieManager::NativeAllowFileSchemeCookies() { return Elastos_AwCookieManager_nativeAllowFileSchemeCookies(TO_IINTERFACE(this)); }
ECode WindowElastos::NativeDestroy( /* [in] */ Handle64 nativeWindowElastos) { Elastos_WindowAndroid_nativeDestroy(TO_IINTERFACE(this), (Handle64)nativeWindowElastos); return NOERROR; }
Handle64 WindowElastos::NativeInit( /* [in] */ Int64 vsyncPeriod) { return Elastos_WindowAndroid_nativeInit(TO_IINTERFACE(this), vsyncPeriod); }
void AwCookieManager::NativeSetAcceptFileSchemeCookies( /* [in] */ Boolean accept) { Elastos_AwCookieManager_nativeSetAcceptFileSchemeCookies(TO_IINTERFACE(this), accept); }
/** * See media/base/android/media_player_listener.cc for all the following functions. */ void MediaPlayerListener::NativeOnMediaError( /* [in] */ Handle64 nativeMediaPlayerListener, /* [in] */ Int32 errorType) { Elastos_MediaPlayerListener_nativeOnMediaError(TO_IINTERFACE(this), nativeMediaPlayerListener, errorType); }
void MediaPlayerListener::NativeOnMediaInterrupted( /* [in] */ Handle64 nativeMediaPlayerListener) { Elastos_MediaPlayerListener_nativeOnMediaInterrupted(TO_IINTERFACE(this), nativeMediaPlayerListener); }
void MediaPlayerListener::NativeOnSeekComplete( /* [in] */ Handle64 nativeMediaPlayerListener) { Elastos_MediaPlayerListener_nativeOnSeekComplete(TO_IINTERFACE(this), nativeMediaPlayerListener); }