下面列出了怎么用com.facebook.react.bridge.Arguments的API类实例代码及写法,或者点击链接到github查看源代码。
private WritableMap getDownloadData(final UploadTask.TaskSnapshot taskSnapshot) {
Uri downloadUrl = taskSnapshot.getDownloadUrl();
StorageMetadata d = taskSnapshot.getMetadata();
WritableMap resp = Arguments.createMap();
resp.putString("downloadUrl", downloadUrl.toString());
resp.putString("fullPath", d.getPath());
resp.putString("bucket", d.getBucket());
resp.putString("name", d.getName());
WritableMap metadataObj = Arguments.createMap();
metadataObj.putString("cacheControl", d.getCacheControl());
metadataObj.putString("contentDisposition", d.getContentDisposition());
metadataObj.putString("contentType", d.getContentType());
resp.putMap("metadata", metadataObj);
return resp;
}
@Test
public void testEmitIntent() {
when(mReactApplicationContext.hasActiveCatalystInstance()).thenReturn(true);
DeviceEventManagerModule.RCTDeviceEventEmitter emitter = PowerMockito.mock(
DeviceEventManagerModule.RCTDeviceEventEmitter.class);
when(mReactApplicationContext.getJSModule(any())).thenReturn(emitter);
when(Arguments.createMap()).thenReturn(PowerMockito.mock(WritableMap.class));
Intent intent = PowerMockito.mock(Intent.class);
when(intent.getStringExtra(KEY_INTENT_EVENT_NAME)).thenReturn("event");
when(intent.getStringExtra(KEY_INTENT_EVENT_TYPE)).thenReturn(INTENT_EVENT_TYPE_BUNDLE);
when(intent.getExtras()).thenReturn(mBundle);
emitIntent(mReactApplicationContext, intent);
verify(mReactApplicationContext, times(1)).hasActiveCatalystInstance();
verify(mReactApplicationContext, times(1)).getJSModule(any());
verify(emitter, times(1)).emit(eq("event"), any(WritableMap.class));
reset(intent);
when(intent.getStringExtra(KEY_INTENT_EVENT_NAME)).thenReturn("event");
when(intent.getStringExtra(KEY_INTENT_EVENT_TYPE)).thenReturn(INTENT_EVENT_TYPE_STRING);
when(intent.getStringExtra(KEY_INTENT_EVENT_STRING_DATA)).thenReturn("data");
emitIntent(mReactApplicationContext, intent);
verify(mReactApplicationContext, times(2)).hasActiveCatalystInstance();
verify(mReactApplicationContext, times(2)).getJSModule(any());
verify(emitter, times(1)).emit("event", "data");
}
@Override
public void onVideoEnabled(SubscriberKit subscriber, String reason) {
String streamId = Utils.getStreamIdBySubscriber(subscriber);
if (streamId.length() > 0) {
ConcurrentHashMap<String, Stream> streams = sharedState.getSubscriberStreams();
Stream mStream = streams.get(streamId);
WritableMap subscriberInfo = Arguments.createMap();
if (mStream != null) {
subscriberInfo.putMap("stream", EventUtils.prepareJSStreamMap(mStream, subscriber.getSession()));
}
subscriberInfo.putString("reason", reason);
sendEventMap(this.getReactApplicationContext(), subscriberPreface + "onVideoEnabled", subscriberInfo);
}
printLogs("onVideoEnabled " + reason);
}
@Override
public void onActivityResult(Activity activity, int requestCode, int resultCode, Intent data) {
if (requestCode == REQUEST_OAUTH) {
mAuthInProgress = false;
if (resultCode == Activity.RESULT_OK) {
// Make sure the app is not already connected or attempting to connect
if (!mApiClient.isConnecting() && !mApiClient.isConnected()) {
mApiClient.connect();
}
} else if (resultCode == Activity.RESULT_CANCELED) {
Log.e(TAG, "Authorization - Cancel");
WritableMap map = Arguments.createMap();
map.putString("message", "" + "Authorization cancelled");
sendEvent(mReactContext, "GoogleFitAuthorizeFailure", map);
}
}
}
@Override
public void onError(SubscriberKit subscriberKit, OpentokError opentokError) {
String streamId = Utils.getStreamIdBySubscriber(subscriberKit);
if (streamId.length() > 0) {
ConcurrentHashMap<String, Stream> streams = sharedState.getSubscriberStreams();
Stream mStream = streams.get(streamId);
WritableMap subscriberInfo = Arguments.createMap();
if (mStream != null) {
subscriberInfo.putMap("stream", EventUtils.prepareJSStreamMap(mStream, subscriberKit.getSession()));
}
subscriberInfo.putMap("error", EventUtils.prepareJSErrorMap(opentokError));
sendEventMap(this.getReactApplicationContext(), subscriberPreface + "onError", subscriberInfo);
}
printLogs("onError: "+opentokError.getErrorDomain() + " : " +
opentokError.getErrorCode() + " - "+opentokError.getMessage());
}
@ReactMethod
public void deauthorize(final String providerName, final Callback onComplete) {
try {
Log.i(TAG, "deauthorizing " + providerName);
HashMap<String,Object> cfg = this.getConfiguration(providerName);
final String authVersion = (String) cfg.get("auth_version");
_credentialsStore.delete(providerName);
WritableMap resp = Arguments.createMap();
resp.putString("status", "ok");
onComplete.invoke(null, resp);
} catch (Exception ex) {
exceptionCallback(ex, onComplete);
}
}
@Override
public boolean onFinishGeoCode(GeoCode geoCode) {
if (geoCode != null) {
WritableMap payload = Arguments.createMap();
payload.putString("displayName", geoCode.getDisplayName());
payload.putString("kind", geoCode.getKind());
payload.putString("title", geoCode.getTitle());
payload.putString("subtitle", geoCode.getSubtitle());
WritableMap point = Arguments.createMap();
GeoPoint geoPoint = geoCode.getGeoPoint();
point.putDouble("latitude", geoPoint.getLat());
point.putDouble("longitude", geoPoint.getLon());
payload.putMap("point", point);
ReactContext reactContext = (ReactContext) getContext();
reactContext.getJSModule(RCTEventEmitter.class).receiveEvent(this.getId(), GEOCODING_EVENT, payload);
}
return true;
}
@ReactMethod
public void lockToLandscapeLeft() {
final Activity activity = getCurrentActivity();
if (activity == null) return;
activity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE);
isLocked = true;
// force send an UI orientation event
lastOrientationValue = "LANDSCAPE-LEFT";
WritableMap params = Arguments.createMap();
params.putString("orientation", lastOrientationValue);
if (ctx.hasActiveCatalystInstance()) {
ctx
.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
.emit("orientationDidChange", params);
}
// send a locked event
WritableMap lockParams = Arguments.createMap();
lockParams.putString("orientation", lastOrientationValue);
if (ctx.hasActiveCatalystInstance()) {
ctx
.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
.emit("lockDidChange", lockParams);
}
}
private WritableArray getAudioTrackInfo() {
WritableArray audioTracks = Arguments.createArray();
MappingTrackSelector.MappedTrackInfo info = trackSelector.getCurrentMappedTrackInfo();
int index = getTrackRendererIndex(C.TRACK_TYPE_AUDIO);
if (info == null || index == C.INDEX_UNSET) {
return audioTracks;
}
TrackGroupArray groups = info.getTrackGroups(index);
for (int i = 0; i < groups.length; ++i) {
Format format = groups.get(i).getFormat(0);
WritableMap audioTrack = Arguments.createMap();
audioTrack.putInt("index", i);
audioTrack.putString("title", format.id != null ? format.id : "");
audioTrack.putString("type", format.sampleMimeType);
audioTrack.putString("language", format.language != null ? format.language : "");
audioTrack.putString("bitrate", format.bitrate == Format.NO_VALUE ? ""
: String.format(Locale.US, "%.2fMbps", format.bitrate / 1000000f));
audioTracks.pushMap(audioTrack);
}
return audioTracks;
}
@ReactMethod
public void scanDevices() {
scanManager.registerCallback(new ScanManager.OnBluetoothScanListener() {
@Override
public void deviceFound(BluetoothDevice bluetoothDevice) {
WritableMap deviceInfoParams = Arguments.createMap();
deviceInfoParams.putString("name", bluetoothDevice.getName());
deviceInfoParams.putString("macAddress", bluetoothDevice.getAddress());
// put deviceInfoParams into callbackParams
WritableMap callbackParams = Arguments.createMap();
callbackParams.putMap("deviceInfo", deviceInfoParams);
callbackParams.putString("state", BluetoothEvent.DEVICE_FOUND.name());
// emit callback to RN code
reactContext.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
.emit("bluetoothDeviceFound", callbackParams);
}
});
scanManager.startScan();
}
WritableMap serializeReader(Reader reader) {
WritableMap writableMap = Arguments.createMap();
if(reader!=null) {
double batteryLevel = 0;
if(reader.getBatteryLevel()!=null)
batteryLevel = (double) reader.getBatteryLevel();
writableMap.putDouble(BATTERY_LEVEL, batteryLevel);
int readerType = 0;
if(reader.getDeviceType()!=null)
readerType = reader.getDeviceType().ordinal();
writableMap.putInt(DEVICE_TYPE, readerType);
String serial = "";
if(reader.getSerialNumber()!=null)
serial = reader.getSerialNumber();
writableMap.putString(SERIAL_NUMBER, serial);
String softwareVersion = "";
if(reader.getSoftwareVersion()!=null)
softwareVersion = reader.getSoftwareVersion();
writableMap.putString(DEVICE_SOFTWARE_VERSION, softwareVersion);
}
return writableMap;
}
@ReactMethod
public void getIpAddress(Callback successCallback, Callback errorCallback) {
WritableArray ipList = Arguments.createArray();
try {
Enumeration<NetworkInterface> enumNetworkInterfaces = NetworkInterface.getNetworkInterfaces();
while (enumNetworkInterfaces.hasMoreElements()) {
NetworkInterface networkInterface = enumNetworkInterfaces.nextElement();
Enumeration<InetAddress> enumInetAddress = networkInterface.getInetAddresses();
while (enumInetAddress.hasMoreElements()) {
InetAddress inetAddress = enumInetAddress.nextElement();
if (inetAddress.isSiteLocalAddress()) {
ipList.pushString(inetAddress.getHostAddress());
}
}
}
} catch (SocketException e) {
Log.e(eTag, "getIpAddress SocketException", e);
errorCallback.invoke(e.getMessage());
}
successCallback.invoke(ipList);
}
@ReactMethod
public void collectPaymentMethod(){
pendingCreatePaymentIntent = Terminal.getInstance().collectPaymentMethod(lastPaymentIntent, this, new PaymentIntentCallback() {
@Override
public void onSuccess(@Nonnull PaymentIntent paymentIntent) {
pendingCreatePaymentIntent = null;
lastPaymentIntent = paymentIntent;
WritableMap collectPaymentMethodMap = Arguments.createMap();
collectPaymentMethodMap.putMap(INTENT,serializePaymentIntent(paymentIntent,lastCurrency));
sendEventWithName(EVENT_PAYMENT_METHOD_COLLECTION,collectPaymentMethodMap);
}
@Override
public void onFailure(@Nonnull TerminalException e) {
pendingCreatePaymentIntent = null;
WritableMap errorMap = Arguments.createMap();
errorMap.putString(ERROR,e.getErrorMessage());
errorMap.putInt(CODE,e.getErrorCode().ordinal());
errorMap.putMap(INTENT,serializePaymentIntent(lastPaymentIntent,lastCurrency));
sendEventWithName(EVENT_PAYMENT_METHOD_COLLECTION,errorMap);
}
});
}
@ReactMethod
public void abortInstallUpdate(){
if(pendingInstallUpdate!=null && !pendingInstallUpdate.isCompleted()){
pendingInstallUpdate.cancel(new Callback() {
@Override
public void onSuccess() {
pendingInstallUpdate = null;
sendEventWithName(EVENT_ABORT_INSTALL_COMPLETION,Arguments.createMap());
}
@Override
public void onFailure(@Nonnull TerminalException e) {
WritableMap errorMap = Arguments.createMap();
errorMap.putString(ERROR,e.getErrorMessage());
sendEventWithName(EVENT_ABORT_INSTALL_COMPLETION,errorMap);
}
});
}else{
sendEventWithName(EVENT_ABORT_INSTALL_COMPLETION,Arguments.createMap());
}
}
private void handleError() {
LogUtils.d(TAG, "handleError");
if(tweetView != null) {
tweetView.setVisibility(View.INVISIBLE);
}
WritableMap evt = Arguments.createMap();
evt.putString("message", "Could not load tweet");
ReactContext ctx = (ReactContext) getContext();
ctx.getJSModule(RCTEventEmitter.class).receiveEvent(
getId(),
"onLoadError",
evt);
}
@Override
public void phoneSignalStrengthsUpdated(SignalStrength signalStrength) {
WritableMap map = Arguments.createMap();
map.putInt("cdmaDbm", signalStrength.getCdmaDbm());
map.putInt("cdmaEcio()", signalStrength.getCdmaEcio());
map.putInt("evdoDbm", signalStrength.getEvdoDbm());
map.putInt("evdoEcio", signalStrength.getEvdoEcio());
map.putInt("evdoSnr", signalStrength.getEvdoSnr());
map.putInt("gsmBitErrorRate", signalStrength.getGsmBitErrorRate());
map.putInt("gsmSignalStrength", signalStrength.getGsmSignalStrength());
map.putBoolean("gsm", signalStrength.isGsm());
WritableMap result = Arguments.createMap();
result.putString("type", "LISTEN_SIGNAL_STRENGTHS");
result.putMap("data", map);
sendEvent(PHONE_STATE_LISTENER, result);
}
@Test
public void testConvertBundleToMapNullArgument() {
WritableMap expectedMap = PowerMockito.mock(WritableMap.class);
when(Arguments.createMap()).thenReturn(expectedMap);
WritableMap map = convertBundleToMap(null);
Assert.assertEquals(map, expectedMap);
verify(expectedMap, times(0)).putNull(anyString());
verify(expectedMap, times(0)).putMap(anyString(), any());
verify(expectedMap, times(0)).putString(anyString(), anyString());
verify(expectedMap, times(0)).putDouble(anyString(), anyDouble());
verify(expectedMap, times(0)).putDouble(anyString(), anyFloat());
verify(expectedMap, times(0)).putInt(anyString(), anyInt());
verify(expectedMap, times(0)).putBoolean(anyString(), anyBoolean());
verify(expectedMap, times(0)).putNull(anyString());
}
@Override
public void onReceive(Context context, Intent intent) {
if (getReactApplicationContext().hasActiveCatalystInstance()) {
String serviceId = intent.getStringExtra("serviceId");
String endpointId = intent.getStringExtra("endpointId");
int payloadType = intent.getIntExtra("payloadType", -1);
String payloadId = intent.getStringExtra("payloadId");
WritableMap out = Arguments.createMap();
out.putString("serviceId", serviceId);
out.putString("endpointId", endpointId);
out.putInt("payloadType", payloadType);
out.putString("payloadId", payloadId);
if (payloadType == Payload.Type.FILE) {
long payloadSize = intent.getLongExtra("payloadSize", -1);
out.putDouble("payloadSize", payloadSize);
}
sendEvent(getReactApplicationContext(), "receive_payload", out);
}
}
/**
* 给rn返回搜索地址
* @param msg
* @param promise
*/
@ReactMethod
public void searchUrl(String msg,Promise promise){
WritableMap map = Arguments.createMap();
map.putBoolean("is_ok", true);
map.putString("data", QtalkNavicationService.getInstance().getSearchurl());
map.putString("Msg",msg);
Logger.i("QTalkLoaclSearch->"+QtalkNavicationService.getInstance().getSearchurl());
try {
promise.resolve(map);
}catch (Exception e){
Logger.i("QTalkLoaclSearch-searchUrl>"+e.getLocalizedMessage());
promise.reject("500",e.toString(),e);
}
}
private void put(String key, List<?> list, WritableMap into) {
if (list == null || list.isEmpty()) {
return;
}
final WritableArray array = Arguments.createArray();
for (Object item: list) {
if (item instanceof String) {
array.pushString((String) item);
}
if (item instanceof Integer) {
array.pushInt((Integer) item);
}
if (item instanceof Boolean) {
array.pushBoolean((Boolean) item);
}
if (item instanceof Double) {
array.pushDouble((Double) item);
}
if (item instanceof Date) {
array.pushString(formatter.format(item));
}
}
into.putArray(key, array);
}
@ReactMethod
public void query(final String sql, final ReadableArray values, final Callback callback) {
new GuardedAsyncTask<Void, Void>(getReactApplicationContext()) {
@Override
protected void doInBackgroundGuarded(Void ...params) {
WritableArray data = Arguments.createArray();
// FLog.w(ReactConstants.TAG, "dbmanager.query.sql=%s", sql);
// FLog.w(ReactConstants.TAG, "dbmanager.query.values.size()=%d", values.size());
try {
data = mDb.query(sql, values);
} catch(Exception e) {
FLog.w(ReactConstants.TAG, "Exception in database query: ", e);
callback.invoke(ErrorUtil.getError(null, e.getMessage()), null);
}
callback.invoke(null, data);
}
}.execute();
}
private WritableMap supportNFC() {
NfcManager manager = (NfcManager) this.reactContext.getSystemService(this.reactContext.NFC_SERVICE);
NfcAdapter adapter = manager.getDefaultAdapter();
WritableMap map = Arguments.createMap();
if (adapter != null) {
map.putBoolean("support", true);
if (adapter.isEnabled()) {
map.putBoolean("enabled", true);
} else {
map.putBoolean("enabled", false);
}
} else {
map.putBoolean("support", false);
map.putBoolean("enabled", false);
}
return map;
}
private void emitOrientationChanged(final int newRotation) {
String name;
double rotationDegrees;
boolean isLandscape = false;
switch (newRotation) {
case Surface.ROTATION_0:
name = "portrait-primary";
rotationDegrees = 0.0;
break;
case Surface.ROTATION_90:
name = "landscape-primary";
rotationDegrees = -90.0;
isLandscape = true;
break;
case Surface.ROTATION_180:
name = "portrait-secondary";
rotationDegrees = 180.0;
break;
case Surface.ROTATION_270:
name = "landscape-secondary";
rotationDegrees = 90.0;
isLandscape = true;
break;
default:
return;
}
WritableMap map = Arguments.createMap();
map.putString("name", name);
map.putDouble("rotationDegrees", rotationDegrees);
map.putBoolean("isLandscape", isLandscape);
sendEvent("namedOrientationDidChange", map);
}
public void onPause(View view) {
long seek = videoView.getCurrentPosition();
playVideo.setVisibility(ImageButton.VISIBLE);
pauseVideo.setVisibility(ImageButton.GONE);
videoView.pause();
WritableMap args = Arguments.createMap();
args.putInt("index", index);
args.putInt("seek", (int) seek);
args.putString("type", "paused");
args.putString("url", playingVideo.getString("url"));
sendEvent(reactContext, "onPause", args);
}
public void onResume(View view) {
long seek = videoView.getCurrentPosition();
playVideo.setVisibility(ImageButton.GONE);
pauseVideo.setVisibility(ImageButton.VISIBLE);
videoView.start();
WritableMap args = Arguments.createMap();
args.putInt("index", index);
args.putInt("seek", (int) seek);
args.putString("type", "resume");
args.putString("url", playingVideo.getString("url"));
sendEvent(reactContext, "onPlay", args);
}
@Override
public void onMapActionEvent(MapEvent mapEvent) {
MapController controller = getMapController();
GeoPoint mapCenter = controller.getMapCenter();
int msg = mapEvent.getMsg();
if (mGeocodingEnabled && msg == MapEvent.MSG_SCALE_END || msg == MapEvent.MSG_SCROLL_END || msg == MapEvent.MSG_ZOOM_END){
controller.getDownloader().getGeoCode(this, mapCenter);
}
Rect viewport = controller.getViewport();
if (viewport.width() == 0 || viewport.height() == 0)
return;
GeoPoint topLeft = controller.getGeoPoint(new ScreenPoint(viewport.left, viewport.top));
GeoPoint bottomRight = controller.getGeoPoint(new ScreenPoint(viewport.right, viewport.bottom));
double latDelta = Math.abs(bottomRight.getLat() - topLeft.getLat());
double lonDelta = Math.abs(bottomRight.getLon() - topLeft.getLon());
WritableMap payload = Arguments.createMap();
payload.putInt("type", msg);
payload.putDouble("latitude", mapCenter.getLat());
payload.putDouble("longitude", mapCenter.getLon());
payload.putDouble("latitudeDelta", latDelta);
payload.putDouble("longitudeDelta", lonDelta);
ReactContext reactContext = (ReactContext) getContext();
reactContext.getJSModule(RCTEventEmitter.class).receiveEvent(this.getId(), MAP_EVENT, payload);
}
@NonNull
private WritableMap getNamesFromContact(int contactId) {
WritableMap names = Arguments.createMap();
String whereString = ContactsContract.Data.CONTACT_ID + " = ? AND " + ContactsContract.Data.MIMETYPE + " = ?";
String[] whereParams = new String[]{String.valueOf(contactId), ContactsContract.CommonDataKinds.StructuredName.CONTENT_ITEM_TYPE };
Cursor namesCursor = contentResolver.query(
ContactsContract.Data.CONTENT_URI,
null,
whereString,
whereParams,
null,
null);
if ( !namesCursor.moveToFirst() ) return names;
String prefix = getStringFromCursor( namesCursor, ContactsContract.CommonDataKinds.StructuredName.PREFIX );
String givenName = getStringFromCursor( namesCursor, ContactsContract.CommonDataKinds.StructuredName.GIVEN_NAME );
String middleName = getStringFromCursor( namesCursor, ContactsContract.CommonDataKinds.StructuredName.MIDDLE_NAME );
String familyName = getStringFromCursor( namesCursor, ContactsContract.CommonDataKinds.StructuredName.FAMILY_NAME );
String suffix = getStringFromCursor( namesCursor, ContactsContract.CommonDataKinds.StructuredName.SUFFIX );
String displayName = getStringFromCursor( namesCursor, ContactsContract.CommonDataKinds.StructuredName.DISPLAY_NAME );
names.putString( "prefix", prefix );
names.putString( "givenName", givenName );
names.putString( "middleName", middleName );
names.putString( "familyName", familyName );
names.putString( "suffix", suffix );
names.putString( "displayName", displayName );
names.putString( "fullName", displayName );
namesCursor.close();
return names;
}
public void onLoadStateChanged(RNRtmpLoadState loadState) {
WritableMap event = Arguments.createMap();
event.putString("state", loadState.getFieldDescription());
ReactContext reactContext = (ReactContext)getContext();
reactContext.getJSModule(RCTEventEmitter.class).receiveEvent(
getId(),
Events.EVENT_LOAD_STATE.toString(),
event);
}
@Override
public void onToastFailed(ErrorInfo errorInfo) {
WritableMap map = Arguments.createMap();
map.putString("error",errorInfo.getErrorText());
map.putString("userInfo", errorInfo.toString());
sendEvent("chatClient:toastFailed", map);
}
private void handleUpdateUnreadCount() {
try {
WritableMap params = Arguments.createMap();
params.putInt("count", Intercom.client().getUnreadConversationCount());
sendEvent(UNREAD_CHANGE_NOTIFICATION, params);
} catch (Exception e) {
Log.e(TAG, "client called before Intercom initialization");
}
}