Java KrollFunction类代码示例

import org.appcelerator.kroll.KrollFunction; //导入依赖的package包/类
/**
 * Request a permission and optionally register a callback for the current activity
 * 
 * @param requestedPermission permission as defined in Manifest
 * @param permissionCallback function called with result of permission prompt
 * @param requestCode - 8 Bit value to associate callback with request - if none is provided a system generated will used
 * @return true in case of valid request, false if requested permission is not a valid one
 */
@Kroll.method
public boolean requestPermission(String requestedPermission,
		@Kroll.argument(optional = true) KrollFunction permissionCallback,
		@Kroll.argument(optional = true) Integer requestCode) {

	Log.d(LCAT, "Requesting permission: " + requestedPermission);

	if (!isValidPermissionString(requestedPermission)) {
		Log.e(LCAT, "Requested permission is not supported :"
				+ requestedPermission);
		return false;
	}

	return handleRequest(new String[]{requestedPermission}, requestCode, permissionCallback);

}
 

import org.appcelerator.kroll.KrollFunction; //导入依赖的package包/类
/**
	 * Request a permission and optionally register a callback for the current activity
	 * 
	 * @param requestedPermissions Array of permissions as defined in Manifest
	 * @param permissionCallback function called with result of permission prompt
	 * @param requestCode - 8 Bit value to associate callback with request - if none is provided, a system generated one is used
	 * @return true in case of valid request, false if requested permission is not a valid one
	 */
	@Kroll.method
	public boolean requestPermissions(@Kroll.argument String[] requestedPerms,
			@Kroll.argument(optional = true) KrollFunction permissionCallback,
			@Kroll.argument(optional = true) Integer requestCode)
			 {

//		String[] requestedPermissions = new String[]{requestedPerms};//(String[])requestedPerms;
		for(String permission:requestedPerms) {
			Log.d(LCAT, "Requesting permission: " + permission);

			if (!isValidPermissionString(permission)) {
				Log.e(LCAT, "Requested permission is not supported :"
						+ permission);
				return false;
			}
		}

		return handleRequest(requestedPerms, requestCode, permissionCallback);

	}
 

import org.appcelerator.kroll.KrollFunction; //导入依赖的package包/类
@Kroll.method
public void registerForPushNotifications(HashMap options) {
	Activity activity = TiApplication.getAppRootOrCurrentActivity();

	if (false == options.containsKey("callback")) {
		Log.e(LCAT, "You have to specify a callback attribute when calling registerForPushNotifications");
		return;
	}

	messageCallback = (KrollFunction)options.get("callback");

	successCallback = options.containsKey("success") ? (KrollFunction)options.get("success") : null;
	errorCallback = options.containsKey("error") ? (KrollFunction)options.get("error") : null;

	parseBootIntent();

	if (checkPlayServices()) {
		activity.startService( new Intent(activity, RegistrationIntentService.class) );
	}
}
 

import org.appcelerator.kroll.KrollFunction; //导入依赖的package包/类
@Kroll.method
public void createObject(String className, final HashMap data, final KrollFunction applicationCallback) {

	SaveCallback parseCallback = new SaveCallback() {
		public void done(ParseException e) {
			HashMap result = new HashMap();

			if (e == null) {
				result.put("object", data);
			} else {
				// There was an error
				result.put("error", e.toString());
			}

			if (applicationCallback != null) {
				applicationCallback.callAsync(getKrollObject(), result);
			}
		}
	};

	parseSingleton.CreateDataObject(className, data, parseCallback);
}
 

import org.appcelerator.kroll.KrollFunction; //导入依赖的package包/类
@Kroll.method
public void updateObject(final HashMap data, final KrollFunction applicationCallback) {
	final ParseObject convertedObject = (ParseObject)ParseDataConversions.ConvertToParseObjectIfNecessary(data);
	SaveCallback parseCallback = new SaveCallback() {
		public void done(ParseException e) {
			HashMap result = new HashMap();
			HashMap returnObject = ParseDataConversions.ObjectToHashMap(convertedObject);
			if (e == null) {
				result.put("object", returnObject);
			} else {
				// There was an error
				result.put("error", e.toString());
			}

			if (applicationCallback != null) {
				applicationCallback.callAsync(getKrollObject(), result);
			}
		}
	};

	parseSingleton.UpdateDataObject(convertedObject, parseCallback);
}
 

import org.appcelerator.kroll.KrollFunction; //导入依赖的package包/类
@Kroll.method
public void deleteObject(String className, String objectId, final KrollFunction applicationCallback) {
	DeleteCallback parseCallback = new DeleteCallback() {
		public void done(ParseException e) {
			HashMap result = new HashMap();
			if (e == null) {
				result.put("success", true);
			} else {
				result.put("error", e.toString());
			}

			applicationCallback.callAsync(getKrollObject(), result);
		}
	};

	parseSingleton.DeleteDataObject(className, objectId, parseCallback);
}
 

import org.appcelerator.kroll.KrollFunction; //导入依赖的package包/类
@Kroll.method
public void registerForPush(String deviceToken, String channelName, KrollFunction applicationCallback) {

	// NOTE: deviceToken is not used, but in order to maintain call
	// compatibility with the iOS module, I'm leaving it as a parameter
	HashMap results = new HashMap();

	// The channel name can only match letters, numbers, dashes and underscores, and must start with a letter
	if (parseSingleton.ValidChannelName(channelName)) {
		parseSingleton.SubscribeToPushChannel(channelName);
		results.put("success", true);
	}
	else {
		// Invalid channel name
		results.put("success", false);
	}

	applicationCallback.callAsync(getKrollObject(), results);
}
 

import org.appcelerator.kroll.KrollFunction; //导入依赖的package包/类
@Kroll.method
public void registerForMultiplePushChannelString(String deviceToken, String channels, KrollFunction applicationCallback) {
	Log.d(LCAT, "String String Callback");
	Log.d(LCAT, channels);
	
	String[] channelNames = channels.split(",");
	
	for ( String s: channelNames){
		Log.d(LCAT, s);
	}
	
	registerForMultiplePushChannelArray(deviceToken, channelNames, applicationCallback);

	// NOTE: deviceToken is not used, but in order to maintain call
	// compatibility with the iOS module, I'm leaving it as a parameter
	//parseSingleton.SubscribeToMultiplePushChannel(channelName);
	
	// This is just a fake call back function the saveEventually() function will be used and no need for callback
	//HashMap results = new HashMap();
	//results.put("success", true);
	//applicationCallback.callAsync(getKrollObject(), results);
}
 

import org.appcelerator.kroll.KrollFunction; //导入依赖的package包/类
@Kroll.method
public void pushChannelList(KrollFunction applicationCallback) {
	HashMap results = new HashMap();

	List<String> channelList = parseSingleton.ChannelSubscriptionList();
	String[] channels = new String[channelList.size()];

	int count = 0;
	for (String channelName : channelList) {
		channels[count] = channelName;
		++count;
	}

	// Store the resulting string list under the 'channels' field for the Titanium App
	results.put("channels", channels);

	applicationCallback.callAsync(getKrollObject(), results);
}
 

import org.appcelerator.kroll.KrollFunction; //导入依赖的package包/类
@Kroll.method
public void valueListener(String ref, KrollFunction change) {
	if (events != null) {
		final KrollFunction changeHandler = change;
		Firebase ch = events.child(ref);
		ch.addValueEventListener(new ValueEventListener() {
			HashMap<String, Object> args = new HashMap<String, Object>();
			String json;
			@Override
			public void onDataChange(DataSnapshot snapshot) {
				json = new Gson().toJson(snapshot.getValue());
	        	args.put("callback", changeHandler);
				args.put("data", json);
				callThisCallbackDirectly(args);
			}
			
			@Override
			public void onCancelled(FirebaseError err) {
				Log.e(TAG, "FirebaseError child.onCancelled: " + err.getMessage());
			}
		});
	}
}
 

import org.appcelerator.kroll.KrollFunction; //导入依赖的package包/类
@Kroll.method
public void singleValueListener(String ref, KrollFunction change) {
	if (events != null) {
		final KrollFunction changeHandler = change;
		Firebase ch = events.child(ref);
		ch.addListenerForSingleValueEvent(new ValueEventListener() {
			HashMap<String, Object> args = new HashMap<String, Object>();
			String json;
			@Override
			public void onDataChange(DataSnapshot snapshot) {
				json = new Gson().toJson(snapshot.getValue());
	        	args.put("callback", changeHandler);
				args.put("data", json);
				callThisCallbackDirectly(args);
			}
			
			@Override
			public void onCancelled(FirebaseError err) {
				Log.e(TAG, "FirebaseError child.onCancelled: " + err.getMessage());
			}
		});
	}
}
 

import org.appcelerator.kroll.KrollFunction; //导入依赖的package包/类
@Kroll.method
public void signin(KrollDict props)
{
	if (props.containsKey("success")) {
		successCallback = (KrollFunction) props.get("success");
	}
	if (props.containsKey("error")) {
		errorCallback = (KrollFunction) props.get("error");
	}
	

	String[] accountTypes = new String[] { GoogleAuthUtil.GOOGLE_ACCOUNT_TYPE };
	Intent intent = AccountPicker.newChooseAccountIntent(null, null,
			accountTypes, false, null, null, null, null);

	Activity activity = TiApplication.getAppCurrentActivity();
	TiActivitySupport support = (TiActivitySupport) activity;
	requestCode = support.getUniqueResultCode();
	support.launchActivityForResult(intent, requestCode, this);

}
 

import org.appcelerator.kroll.KrollFunction; //导入依赖的package包/类
private boolean handleRequest(String[] permissions, Integer requestCode, KrollFunction permissionCallback) {
	Activity activity = TiApplication.getAppCurrentActivity();

	if (!(activity instanceof TiBaseActivity)) {
		Log.w(LCAT,	"Requesting permission from non-Titanium activity - not supported");
		return false;
	}

	TiBaseActivity currentActivity = (TiBaseActivity) activity;
	// Do we need a callback and request code in any case?
	if (requestCode == null) {
		Log.d(LCAT, "No request code given - Ti Permissions module will generate one");
		requestCode = currentActivity.getUniqueResultCode();
	}

	// register callback in current activity
	// TODO what is the exact purpose of the context? We should provide the Activity's Proxy, not the module object
	KrollObject context = currentActivity.getActivityProxy().getKrollObject();

	Log.d(LCAT, "Registering callback");
	currentActivity.registerPermissionRequestCallback(requestCode, 
			permissionCallback, context,permissions);

	Log.d(LCAT, "Calling permission request");
	ActivityCompat.requestPermissions(activity,	permissions, requestCode);
	return true;
}
 

import org.appcelerator.kroll.KrollFunction; //导入依赖的package包/类
@Kroll.method
public void unsubscribeFromPush(String channelName, KrollFunction applicationCallback) {

	HashMap results = new HashMap();

	if (parseSingleton.ValidChannelName(channelName)) {
		parseSingleton.UnsubscribeFromPushChannel(channelName);
		results.put("success", true);
	}
	else {
		results.put("success", false);
	}

	applicationCallback.callAsync(getKrollObject(), results);
}
 

import org.appcelerator.kroll.KrollFunction; //导入依赖的package包/类
@Kroll.method
public void registerForSinglePushChannel(String deviceToken, String channelName, KrollFunction applicationCallback) {
	// NOTE: deviceToken is not used, but in order to maintain call
	// compatibility with the iOS module, I'm leaving it as a parameter
	parseSingleton.SubscribeToSinglePushChannel(channelName);
	
	// This is just a fake call back function the saveEventually() function will be used and no need for callback
	HashMap results = new HashMap();
	results.put("success", true);
	applicationCallback.callAsync(getKrollObject(), results);
}