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);
}
