来源: 互联网  发布时间: 2014-02-18

图片下载工具类：BitmapUtil
http://blog.csdn.net/flying_vip_521/article/details/7656413

package com.net.util;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.ArrayList;
import java.util.List;

import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.os.Environment;
import android.util.Log;
/**
 * 图片下载工具类
 * 
 * @author gaozhibin
 *
 */
public class BitmapUtil {
	private static final String TAG = "BtimapUtil";
	

	/**
	 * 根据网址获得图片，优先从本地获取，本地没有则从网络下载
	 * 
	 * @param url  图片网址
	 * @param context 上下文
	 * @return 图片
	 */
	public static Bitmap getBitmap(String url,Context context){
		Log.e(TAG, "------url="+url);
		String imageName= url.substring(url.lastIndexOf("/")+1, url.length());
		File file = new File(getPath(context),imageName);
		if(file.exists()){
			Log.e(TAG, "getBitmap from Local");
			return BitmapFactory.decodeFile(file.getPath());
		}
		return getNetBitmap(url,file,context);
	}
	
	/**
	 * 根据传入的list中保存的图片网址，获取相应的图片列表
	 * 
	 * @param list  保存图片网址的列表
	 * @param context 上下文
	 * @return 图片列表
	 */
	public static List<Bitmap> getBitmap(List<String> list,Context context){
		List<Bitmap> result = new ArrayList<Bitmap>();
		for(String strUrl : list){
			Bitmap bitmap = getBitmap(strUrl,context);
			if(bitmap!=null){
				result.add(bitmap);
			}
		}
		return result;
	}

	/**
	 * 获取图片的存储目录，在有sd卡的情况下为 “/sdcard/apps_images/本应用包名/cach/images/”
	 * 没有sd的情况下为“/data/data/本应用包名/cach/images/”
	 * 
	 * @param context 上下文
	 * @return 本地图片存储目录
	 */
	private static String getPath(Context context){
		String path = null;
		boolean hasSDCard = Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED);
		String packageName = context.getPackageName()+"/cach/images/";
		if(hasSDCard){
			path="/sdcard/apps_images/"+packageName;
		}else{
			path="/data/data/"+packageName;		
		}  
		File file = new File(path);
		boolean isExist = file.exists();
		if(!isExist){
			
			file.mkdirs();
			
		}
		return file.getPath();
	}

	/**
	 * 网络可用状态下，下载图片并保存在本地
	 * 
	 * @param strUrl 图片网址
	 * @param file 本地保存的图片文件
	 * @param context  上下文
	 * @return 图片
	 */
	private static Bitmap getNetBitmap(String strUrl,File file,Context context) {
		Log.e(TAG, "getBitmap from net");
		Bitmap bitmap = null;
		if(NetUtil.isConnnected(context)){
			try {
				URL url = new URL(/blog_article/strUrl/index.html);
				HttpURLConnection con = (HttpURLConnection) url.openConnection();
				con.setDoInput(true);
				con.connect();
				InputStream in = con.getInputStream();
				bitmap = BitmapFactory.decodeStream(in);
				FileOutputStream out = new FileOutputStream(file.getPath());
				bitmap.compress(Bitmap.CompressFormat.PNG,100, out);
				out.flush();
				out.close();
				in.close();
			} catch (MalformedURLException e) {
				e.printStackTrace();
			} catch (IOException e) {
				e.printStackTrace();
			} finally{
				
			}			
		}
		return bitmap;
	}
	
}

Android 之 远程图片获取和本地缓存
http://blog.csdn.net/xieqibao/article/details/6682128

package com.net.util;

import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.util.List;
import org.apache.http.HttpResponse;
import org.apache.http.HttpStatus;
import org.apache.http.NameValuePair;
import org.apache.http.client.ClientProtocolException;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.client.methods.HttpUriRequest;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.util.EntityUtils;
import org.json.JSONException;
import org.json.JSONObject;
import android.content.Context;
import android.net.ConnectivityManager;
import android.net.NetworkInfo;
import android.util.Log;
import android.widget.Toast;

public class NetUtil {
	private static final String TAG = "NetUtil";

	/**
	 * 网络连接是否可用
	 */
	public static boolean isConnnected(Context context) {
		ConnectivityManager connectivityManager = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
		if (null != connectivityManager) {
			NetworkInfo networkInfo[] = connectivityManager.getAllNetworkInfo();

			if (null != networkInfo) {
				for (NetworkInfo info : networkInfo) {
					if (info.getState() == NetworkInfo.State.CONNECTED) {
						Log.e(TAG, "the net is ok");
						return true;
					}
				}
			}
		}
		Toast.makeText(context, "网络连接失败", Toast.LENGTH_SHORT).show();
		return false;
	}

	/**
	 * 网络可用状态下，通过get方式向server端发送请求，并返回响应数据
	 * 
	 * @param strUrl 请求网址
	 * @param context 上下文
	 * @return 响应数据
	 */
	public static JSONObject getResponseForGet(String strUrl, Context context) {
		if (isConnnected(context)) {
			return getResponseForGet(strUrl);
		}
		return null;
	}

	/**
	 * 通过Get方式处理请求，并返回相应数据
	 * 
	 * @param strUrl 请求网址
	 * @return 响应的JSON数据
	 */
	public static JSONObject getResponseForGet(String strUrl) {
		HttpGet httpRequest = new HttpGet(strUrl);
		return getRespose(httpRequest);
	}

	/**
	 * 网络可用状态下，通过post方式向server端发送请求，并返回响应数据
	 * 
	 * @param market_uri 请求网址
	 * @param nameValuePairs 参数信息
	 * @param context 上下文
	 * @return 响应数据
	 */
	public static JSONObject getResponseForPost(String market_uri, List<NameValuePair> nameValuePairs, Context context) {
		if (isConnnected(context)) {
			return getResponseForPost(market_uri, nameValuePairs);
		}
		return null;
	}

	/**
	 * 通过post方式向服务器发送请求，并返回响应数据
	 * 
	 * @param strUrl 请求网址
	 * @param nameValuePairs 参数信息
	 * @return 响应数据
	 */
	public static JSONObject getResponseForPost(String market_uri, List<NameValuePair> nameValuePairs) {
		if (null == market_uri || "" == market_uri) {
			return null;
		}
		HttpPost request = new HttpPost(market_uri);
		try {
			request.setEntity(new UrlEncodedFormEntity(nameValuePairs));
			return getRespose(request);
		} catch (UnsupportedEncodingException e1) {
			e1.printStackTrace();
		}
		return null;
	}

	/**
	 * 响应客户端请求
	 * 
	 * @param request 客户端请求get/post
	 * @return 响应数据
	 */
	public static JSONObject getRespose(HttpUriRequest request) {
		try {
			HttpResponse httpResponse = new DefaultHttpClient().execute(request);
			int statusCode = httpResponse.getStatusLine().getStatusCode();
			if (HttpStatus.SC_OK == statusCode) {
				String result = EntityUtils.toString(httpResponse.getEntity());
				Log.i(TAG, "results=" + result);
				return new JSONObject(result);
			}
		} catch (ClientProtocolException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} catch (JSONException e) {
			e.printStackTrace();
		}
		return null;
	}
}

Log输出到sdcard工具类
http://blog.csdn.net/flying_vip_521/article/details/7652572

package com.innofidei;

import java.io.File;
import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class LocatUtil {
	private static String logToFileCommand = "logcat -v time -f ";

	public static void startLog(String saveiDir, String fileName) {
		SimpleDateFormat format = new SimpleDateFormat("yyMMdd_HHmmss");
		String nowStr = format.format(new Date());
		fileName = fileName + "_" + nowStr + ".txt";
		new File(saveiDir).mkdirs();
		try {
			Runtime.getRuntime().exec(logToFileCommand + saveiDir + fileName);
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}

GSPUtil

package org.join.weather.util;


import java.util.List;


import org.join.weather.WeatherActivity;
import org.join.weather.WeatherActivity.OnActivityResumeAndPauseListener;


import android.app.AlertDialog;
import android.content.Context;
import android.content.Intent;
import android.location.Address;
import android.location.Criteria;
import android.location.Geocoder;
import android.location.Location;
import android.location.LocationListener;
import android.location.LocationManager;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.preference.PreferenceManager.OnActivityResultListener;
import android.provider.Settings;
import android.util.Log;
import android.widget.Toast;


public class GPSUtil implements OnActivityResultListener,
		OnActivityResumeAndPauseListener {


	// WeatherActivity对象
	private WeatherActivity weatherActivity;
	// LocationManager对象
	private LocationManager locationManager;
	// Location对象
	private Location location;
	// 当前位置提供者
	private String provider;


	// 时间（秒）
	private long minTime = 60 * 1000;
	// 距离（米）
	private float minDistance = 500;
	// 定位方式
	private int mode = 1;


	// 位置监听接口
	private LocationListener mLocationListener = new LocationListener() {


		@Override
		public void onLocationChanged(final Location loc) {
			// 当坐标改变时触发此函数，如果Provider传进相同的坐标，它就不会被触发
			Log.v("onLocationChanged", "=onLocationChanged");


			if (loc != null) {
				location = loc;
				showLocationInfo(loc);
			} else {
				Toast.makeText(weatherActivity, "当前位置不可定位！", Toast.LENGTH_SHORT)
						.show();
				// 注销监听事件
				// locationManager.removeUpdates(mLocationListener);
			}
		}


		@Override
		public void onProviderDisabled(String provider) {
			// Provider被disable时触发此函数，比如GPS被关闭
			Log.v("onProviderDisabled", "=onProviderDisabled");
		}


		@Override
		public void onProviderEnabled(String provider) {
			// Provider被enable时触发此函数，比如GPS被打开
			Log.v("onProviderEnabled", "=onProviderEnabled");
		}


		@Override
		public void onStatusChanged(String provider, int status, Bundle extras) {
			// Provider的转态在可用、暂时不可用和无服务三个状态直接切换时触发此函数
			Log.v("onStatusChanged", "=onStatusChanged");
		}
	};


	// 超时注销服务
	private Handler myHandler = new Handler() {


		@Override
		public void handleMessage(Message msg) {
			if (null == location) {
				// 提示信息
				Toast.makeText(weatherActivity, "当前位置不可定位！", Toast.LENGTH_SHORT)
						.show();
			}
			// 注销监听事件
			locationManager.removeUpdates(mLocationListener);
		}


	};


	public GPSUtil(WeatherActivity weatherActivity, int mode) {
		this.weatherActivity = weatherActivity;
		weatherActivity.setOnActivityResultListener(this);
		weatherActivity.setOnResumeAndPauseListener(this);
		this.mode = mode;


		// 获得LocationManager服务
		locationManager = (LocationManager) weatherActivity
				.getSystemService(Context.LOCATION_SERVICE);


		if (openGPSSettings()) {
			setLocationServer(mode);
		} else {
			Toast.makeText(weatherActivity, "请开启GPS！", Toast.LENGTH_SHORT)
					.show();
			Intent intent = new Intent(Settings.ACTION_SECURITY_SETTINGS);
			// 此为设置完成后返回到获取界面
			weatherActivity.startActivityForResult(intent, 0);
		}


	}


	public GPSUtil(WeatherActivity weatherActivity, int mode, long minTime,
			float minDistance) {
		this(weatherActivity, mode);
		this.minTime = minTime;
		this.minDistance = minDistance;
	}


	// 判断GPS模块是否存在或者是开启
	private boolean openGPSSettings() {
		if (locationManager
				.isProviderEnabled(android.location.LocationManager.GPS_PROVIDER)) {
			return true;
		}
		return false;
	}


	// 更新当前位置信息（如果使用GPS，需要保证在室外，并且没有大建筑物遮挡，如果使用网络定位，要保证网络通畅）
	public void setLocationServer(int mode) {


		Toast.makeText(weatherActivity, "正在定位！", Toast.LENGTH_SHORT).show();


		switch (mode) {
		case 1: {
			// GPS定位
			if (locationManager.isProviderEnabled(LocationManager.GPS_PROVIDER)) {
				provider = LocationManager.GPS_PROVIDER;
				location = locationManager.getLastKnownLocation(provider);
				// 设置监听器，自动更新的最小时间为间隔N秒或最小位移变化超过N米
				locationManager.requestLocationUpdates(provider, minTime,
						minDistance, mLocationListener);
				Log.v("GPS定位", "GPS定位！");
			} else {
				Log.v("GPS定位", "未提供GPS定位功能！");
			}
			break;
		}
		case 2: {
			// NETWORK定位
			provider = LocationManager.NETWORK_PROVIDER;
			location = locationManager.getLastKnownLocation(provider);
			// 设置监听器，自动更新的最小时间为间隔N秒或最小位移变化超过N米
			locationManager.requestLocationUpdates(provider, minTime,
					minDistance, mLocationListener);
			Log.v("NETWORK定位", "NETWORK定位！");
			break;
		}
		case 3: {
			// 查询符合条件的Location Provider来定位


			// 获得Criteria对象（指定条件参数）
			Criteria criteria = new Criteria();
			// 获得最好的单位效果
			criteria.setAccuracy(Criteria.ACCURACY_FINE);
			criteria.setAltitudeRequired(false);
			criteria.setBearingRequired(false);
			criteria.setCostAllowed(false);
			// 使用省电模式
			criteria.setPowerRequirement(Criteria.POWER_LOW);
			// 获得当前位置的提供者
			provider = locationManager.getBestProvider(criteria, true);
			// 获得当前位置
			location = locationManager.getLastKnownLocation(provider);


			if (null != provider) {
				// 设置监听器，自动更新的最小时间为间隔N秒或最小位移变化超过N米
				locationManager.requestLocationUpdates(provider, minTime,
						minDistance, mLocationListener);
			} else {
				Log.v("provider", "null == provider");
			}
			Log.v("最优定位", provider);
			break;
		}
		}


		if (null != location) {
			showLocationInfo(location);
		}
		// 延迟10秒
		myHandler.sendEmptyMessageDelayed(0, 10 * 1000);
	}


	// 显示定位信息
	private void showLocationInfo(Location loc) {


		String msg = "";


		try {
			msg = "经度：" + location.getLongitude() + "\n";
			msg += "纬度：" + location.getLatitude() + "\n";
			Geocoder gc = new Geocoder(weatherActivity);
			List<Address> addresses = gc.getFromLocation(
					location.getLatitude(), location.getLongitude(), 1);
			// 相关信息
			if (addresses.size() > 0) {
				msg += "AddressLine：" + addresses.get(0).getAddressLine(0)
						+ "\n";
				msg += "CountryName：" + addresses.get(0).getCountryName()
						+ "\n";
				msg += "Locality：" + addresses.get(0).getLocality() + "\n";
				msg += "FeatureName：" + addresses.get(0).getFeatureName();
			}
		} catch (Exception e) {
			msg = e.getMessage();
		}


		new AlertDialog.Builder(weatherActivity).setMessage(msg)
				.setPositiveButton("确定", null).show();
	}


	@Override
	public boolean onActivityResult(int requestCode, int resultCode, Intent data) {
		// 从设置GPS的Activity返回时
		if (0 == requestCode) {
			if (openGPSSettings()) {
				setLocationServer(mode);
			} else {
				Toast.makeText(weatherActivity, "GPS仍未开启！", Toast.LENGTH_SHORT)
						.show();
			}
		}
		return false;
	}


	// 在Activity恢复活动时，响应位置更新
	@Override
	public void onResume() {
		if (null != provider) {
			locationManager.requestLocationUpdates(provider, minTime,
					minDistance, mLocationListener);
		}
	}


	// 在Activity暂停活动时，取消位置更新
	@Override
	public void onPause() {
		if (null != locationManager) {
			locationManager.removeUpdates(mLocationListener);
		}
	}


}

WebService for Android

获取手机ip地址工具类

package com.innofidei.location;

import java.net.InetAddress;
import java.net.UnknownHostException;

import android.content.Context;
import android.net.wifi.WifiManager;

public class AdressUtil {
	public String getIp(Context myContext) {
		InetAddress address = getWifiIp(myContext);
		if (address != null) {
			return address.getHostAddress();
		}
		return null;
	}

	private InetAddress getWifiIp(Context myContext) {
		if (myContext == null) {
			throw new NullPointerException("Global context is null");
		}
		WifiManager wifiMgr = (WifiManager) myContext.getSystemService(Context.WIFI_SERVICE);
		if (isWifiEnabled(myContext)) {
			int ipAsInt = wifiMgr.getConnectionInfo().getIpAddress();
			if (ipAsInt == 0) {
				return null;
			} else {
				return intToInet(ipAsInt);
			}
		} else {
			return null;
		}
	}

	private boolean isWifiEnabled(Context myContext) {
		if (myContext == null) {
			throw new NullPointerException("Global context is null");
		}
		WifiManager wifiMgr = (WifiManager) myContext.getSystemService(Context.WIFI_SERVICE);
		if (wifiMgr.getWifiState() == WifiManager.WIFI_STATE_ENABLED) {
			return true;
		} else {
			return false;
		}
	}

	private InetAddress intToInet(int value) {
		byte[] bytes = new byte[4];
		for (int i = 0; i < 4; i++) {
			bytes[i] = byteOfInt(value, i);
		}
		try {
			return InetAddress.getByAddress(bytes);
		} catch (UnknownHostException e) {
			// This only happens if the byte array has a bad length
			return null;
		}
	}

	private byte byteOfInt(int value, int which) {
		int shift = which * 8;
		return (byte) (value >> shift);
	}
}

工具类：字符串处理
工具类：日期处理
工具类：加密（java）
工具类：判断一个类是否是给定类的子类

public class ClassUtils {

    /**
     * Checks if a class is a subclass of a class with the specified name. Used
     * as an instanceOf without having to load the class, useful when trying to
     * check for classes that might not be available in the runtime JRE.
     * 
     * @param clazz
     *            The class to check
     * @param className
     *            The class name to look for in the super classes
     * @return true if the class extends a class by the specified name.
     */
    public static boolean extendsClass(final Class<?> clazz, String className) {
        Class<?> superClass = clazz.getSuperclass();

        while (superClass != null) {
            if (superClass.getName().equals(className)) {
                return true;
            }
            superClass = superClass.getSuperclass();

        }
        return false;
    }
}

android时时监听log

    

    来源: 互联网  发布时间: 2014-02-18

线程池中所有线程结束捕捉

  下面的代码只是一个引子或者一种方案。    

  ThreadPoolExecutor threadPool=new ThreadPoolExecutor(20, 50, 50000,TimeUnit.MILLISECONDS
            , new ArrayBlockingQueue<Runnable>(5, true));
        for(int i=0;i<30;i++)
        {
            threadPool.execute(new Runnable()
            {
                public void run()
                {
                    try
                    {
                        int random=getRandom(500, 4000);
                        Thread.sleep(random);
                        ++count;
                        if(count>=30)
                        {
                          System.out.println("All Thread is Finished!!!!!!!!!!!!!!"); 
                        }
                    }catch (InterruptedException e){}
                }
            });
        }

    

    来源: 互联网  发布时间: 2014-02-18

Rexsee Hello World - 基于Rexsee项目中心的在线开发入门指导

 

 

 

概览

作为开源的Android应用开发平台，Rexsee提供了接近2000个扩展API，不仅简化了Android原生开发，更支持Web开发者基于标准化Web开发模式，使用HTML、CSS和Javascript快速实现移动应用。

本文将细致讲述如何基于Rexsee社区的项目中心，在线实现我们的第一个Hello World程序。

在Rexsee项目中心创建新项目

         登录Rexsee社区，并进入项目中心，点击左侧头部的“创建新项目”即可开始咱们的Hello World应用创建。

1.   应用信息填写

a)  应用包名：程序的包名，英文字母开头，可以包含字母、数字和下划线。

b)  版本信息：应用的版本说明，使用数字和“.”，例如1.5。

c)  应用名称：显示在手机应用程序列表和手机桌面上的名称，支持英文或中文。

d)  应用图标：显示在手机应用程序列表和手机桌面上的图标，72x72的png图片。

2.    选择扩展组件

3.    基本设置与权限选择

Rexsee提供了大量的原生功能实现，你可以结合具体应用的功能在创建时进行勾选。

4.     分享

作为Rexsee项目中心最为重要的功能之一，社区鼓励开发者以开放的形式共享应用，更多的访问者不仅可以直接下载应用，更能从源码层面得以了解和学习。

系统默认为分享状态，即其他开发者可以在项目中心查看您的应用。

代码编写与调试

         项目创建成功后即可进入到开发页面。在这里我们可以查看到应用的相关属性以及文件组成。

         点击“编辑”index.html页面，开始咱们的Hello World。

1.    Hello World代码编写

在index.html页面中输入如下代码

 

 

代码说明：

 

• Rexsee提供的是JS API，可以在html中加入<script type=text/javascript></script>标签；也可以在外部文件中添加JS代码，然后通过<script type=text/javascript src="/blog_article/你的外部javascript地址/index.html">引用；
• 本段代码中用到了window.onRexseeReady=function（），当系统加载完毕后将会执行{}中的JS语句；
• rexseeDialog.toast()，这行代码执行时会弹出一个随即消失的对话框；
• 更多详细的JS对象和事件说明请在Rexsee社区的“手册与源码”中获取，或者下载Rexsee开发手册

 

2.     调试

a)        利用Rexsee开发版进行调试

Rexsee开发版是一个专门用于调试Rexsee应用的软件，在社区的快速入门中已经有所介绍。开发者可以访问如下链接，免费下载Rexsee开发版，并安装在测试用的Android手机，或者模拟器上。

在开发版的“首页地址”中输入程序链接地址，即刚刚创建的index.html页面地址，就可以看到程序效果。

       

b)        直接生成apk应用程序

当然，这只是一个简单的应用示例，你大可直接编译生成apk应用程序，安装并试用即可。

3.   进一步尝试

接下来，我们让这段代码变得复杂一些。

a)         代码修改和提交

进入我的项目，并点击“编辑”进入index.html页面的修改中，将JS代码调整为如下内容：

 

代码说明：

本段代码新增了标题栏以及菜单布局，一般有如下几个步骤完成：

1)         隐藏系统的标题栏：rexseeTitleBar.setStyle('visibility:hidden;');

2)         判断某个标题栏是否存在，标题栏创建之后在整个应用中会一直存在，所以在创建的时候需要判断，是否已经存在过此标题栏，防止重复创建：

if (!rexseeMenu.exists('head'))      //设置头部标签栏菜单

3)         创建一个标签栏，作为标签栏菜单：rexseeMenu.create('head');            

4)         向标签栏菜单中添加标签：

rexseeMenu.addItem('head','rexsee:','label:Rexsee Hello World;'+normalStyle);

         按如下图片示意中，点击“提交”即可更新页面代码。

和之前介绍的调试方法一致，打开开发版，无需重新载入首页地址，直接刷新即可打开调整后的应用。

在线编译，生成apk应用程序

         在代码编写完成之后，点击项目右上角的“编译”按钮。

         系统将在线为你编译生成apk应用程序。

         编译成功后，你可以获得一个apk下载地址，以及二维码图形。

点击“返回项目”，你可以将此应用提交到Rexsee应用市场，或通过别的第三方应用市场发布并推广你的应用。

直接向你的用户分发你在上面生成的Rexsee客户端即可。你的用户安装后，运行该客户端会直接跳转到你的应用首页。

到此，一个 Android应用就完成了，对你而言，就是在上线一个普通网站。

关于升级与维护

 

• 客户端升级
  • 如果你需要进行业务调整，需要重新设计客户端的界面，直接修改index页面即可。
  • 如果你需要更改客户端的样式，只需维护相关的样式表即可。
• 通常情况下，你不需要更新（重新搬移）Rexsee应用客户端。除非：
  • 需要更改Rexsee程序图标或者程序相关信息等。
  • 需要更改Rexsee客户端的首页地址。
  • 需要增加Rexsee域白名单记录等软件许可。
  • Rexsee平台提供了新功能或者修复了一些Bug。

 

附：不使用项目中心的开发流程说明

或者，你也可以在本地进行开发，利用Rexsee的在线编译实现应用，而非使用项目中心的在线开发服务。

你只需将上面示例中的代码编写为index.html文件，然后打包为zip格式文件。点击如下链接进入Rexsee社区的“在线编译”频道。

相关的信息与之前的介绍一致，唯一需要注意的是“高级设置”中的“预打包”处理。

说明：理论上你可以把除了后台代码之外的东西都打包到zip包里，比如一些图片，音视频文件，或者html的框架文件，css文件，js文件。但实际操作下，考虑到安全、网络速度、流量、体验，需要根据项目来安排。

提交后即可生成apk应用程序，分发与运维流程与之前的介绍一致。

后记

Rexsee是国内开源的Android应用开发平台：

 

• 以Webkit为内核，使用标准化Web开发模式实现应用；
• 强化HTML5在浏览器之外的高度交互特性；
• 扩展接近2000个API，深度支持Android系统平台；
• 覆盖95%的Android原生功能，支持原生UI布局；
• 符合W3C标准，完全兼容第三方开发框架；
• 提供本地应用与云端应用的不同运行形态。