这只是一个很小的应用，先上需求吧。
| 逻辑： 1.激活不是强制的：不激活也能用，只是每次显示设置时候提示督促激活的对话框。 激活不是自动的：比如人为操作来激活。 2.是否已经激活的标记 通过在用户数据区域保存特定变量来实现。数据不能保存在应用本身的数据区域，因为其他应用也要读取这个数据，比如设置。 当用户通过recovery等其他工具将用户数据区域清空，或者恢复出厂设置的话，又变回未激活状态。 minzuos_activated: "0"/"1"，字符串 "0"：系统还未激活,如果变量不存在，那么也算是未激活。 "1"：系统已经激活。 minzuos_datetime: 整数的字符串形式，"1434088755"，以秒为单位的时间戳，UNIX时间。 激活的时间，是服务器返回的整数，不是客户端自动生成的。因为手机时间是可以改的。 3.激活过程 3.1 独立开发一个激活应用：romact.apk。存放在system区域。不能删除。 应用信息：文件名romact.apk，目录名romact，类包名com.minzuos.romactivate 界面制作中文语言，其他语言不支持。 3.2 激活应用启动时间 每次启动（第一次启动）或者显示（应用间切换）[设置]settings.apk的时候做是否已经激活的判断。 已激活：不做任何处理，继续设置操作。 未激活：判断网络（WIFI网络,移动网络）是否可用。 网络不可用：不做任何处理，继续设置过程。 网络可用 ：启动激活应用。 3.3 激活应用参考设计画面。 3.4 激活过程是访问远程服务器，然后记录返回数值。 网址:http://www.minzuos.com/xdo/doactivate.php [^] 参数:要用POST方式，不用GET方式 romversion:MINZUOS版本，如：1.0.0-20150507-bacon brand:手机厂家，品牌，如：Xiaomi model:手机型号，如：2014811 device:手机设备，如：HM2014811 imei:手机序列号：737832127908765 响应数据：是json格式的数据 { status:"1",1=成功，1以外失败。 datetime:"1434088755", message:"服务器给客户端端的文本信息，status=1时候，成功信息，status!=1时候失败信息！" } ※无论成功与否，客户端都要显示由服务器返回的激活信息！ ================================================================= 获取手机信息： 1.ROMVERSION 系统ROM版本号 就是MINZUOS版本，如：1.0.0-20150507-bacon 其实就是包名minzuos-1.0.0-20150507-bacon.zip的一部分。 怎么获取？ 2.BRAND 可能就是手机厂家，或者品牌。也许是子品牌 ro.product.brand=oneplus 3.MODEL 手机型号 ro.product.model=A0001 4.DEVICE 就是具体型号 ro.product.device=A0001 5.IMEI 如果是双卡，那么读取主卡（第一个）的。 |
大致讲解下，入口有三个，第一个是开机启动会自动启动romact.apk，第二个是打开setting设置的时候，启动
romact.apk。（这两个也不是每次都要启动，是需要判断的，系统是否激活，会在system区域保存一个常量值，如果激活，就会保存1，如果未激活，就会保存0.每次启动开机或者启动setting的时候，就会第一时间查询本地的状态值，然后决定是否启动romact.apk。如果本身已经激活了系统，不管是开机还是打开setting，都不会再启动romacr.apk了。）第三个就是独立打开romact.apk。
首先，这里用到了我以前从来没有用过也没有见过的属于系统的方法，存值和取值。
取值：Settings.System.getInt(ContentResolver cr, String name,int def)
存值：Settings.System.putInt(ContentResolver cr, String name, int def)
这两个方法的返回值类型是int类型，然后导包是android.provider.Settings
注：getint方法需要加权限<uses-permission android:name="android.permission.WRITE_SETTINGS" />
否则会报错。
-
Parameters:
- cr The ContentResolver to access.
- name The name of the setting to retrieve.
- def Value to return if the setting is not defined. Returns: The setting's current value, or 'def' if it is not defined or not a valid integer.
第一个参数一般只需要歇上getContentResolver()，
第二个参数名字，好比是键值对，get和int的名字必须一致，才会共享存取的值。(名字自己随便取)
第三个参数，对于getInt()方法来说，当这个存储空间还没有建立，第一次取值不存在的时候，取到的是所给定的第三个参数，(这个值只用一次，就是第一次取值时候的默认值。以后的取值都是从空间中去，是多少就是多少。存储空间的值是put进去的)。对于putInt()方法来说，想调用存值的时候，只需要把自己的值存进去就可以了。
这中方法直接将值存到了系统的区域。
对于开机或者打开setting，当条件满足，启动romact.apk，是需要在romact.apk中写一个广播接受者，来接受前两者发送的广播。
<!-- 注册开机启动的广播接收器 -->
<receiver android:name=".RomactReceiver" >
<intent-filter>
<action android:name="android.intent.action.BOOT_COMPLETED" />
<action android:name="com.android.minzuos.romactivate.start.activate" />
<category android:name="android.intent.category.DEFAULT" />
</intent-filter>
</receiver><span style="font-size:14px;">当Android启动时，会发送以个广播，内容为：ACTION_BOOT_COMPLETED。它的字符串常量为android.intent.action.BOOT_COMPLETED</span>第二个action 是用来匹配启动setting所发送的广播。
这是setting所发送的广播，这是一种隐式启动。
String boradcastIntent = "com.android.minzuos.romactivate.start.activate";
Intent intent = new Intent(boradcastIntent);
this.sendBroadcast(intent);这是romact.apk接受广播的类
package com.minuzuos.romactivate;
import android.R.integer;
import android.content.BroadcastReceiver;
import android.content.ContentResolver;
import android.content.Context;
import android.content.Intent;
import android.content.SharedPreferences;
import android.database.Cursor;
import android.net.ConnectivityManager;
import android.net.NetworkInfo;
import android.net.NetworkInfo.State;
import android.net.Uri;
import android.os.Handler;
import android.preference.CheckBoxPreference;
import android.preference.PreferenceManager;
import android.provider.Settings;
import android.util.Log;
import android.widget.Toast;
public class RomactReceiver extends BroadcastReceiver {
static final String ACTION_BOOT = "android.intent.action.BOOT_COMPLETED";
static final String ACTION_NETCHANGE = "android.net.conn.CONNECTIVITY_CHANGE";
static final String ACTION_SETTING = "com.android.minzuos.romactivate.start.activate";
private final static String SETTING_MODIFY_NAME = "com.minzuos.romactivate.activate.status";
private final static String IS_OPEN_FLAG = "isornot.open.flag";
String action = "";
public SharedPreferences preferences;
@Override
public void onReceive(Context context, Intent intent) {
preferences = PreferenceManager.getDefaultSharedPreferences(context);
action = intent.getAction();
boolean net_status = checkNetStatus(context);
Log.i("test_pass", "当前网络状态" + net_status);
// 一进来，首先知道是否激活，如果已经激活，就什么也不干，如果未激活，在进行判断操作
int activate_status = Settings.System.getInt(
context.getContentResolver(), SETTING_MODIFY_NAME, 0);
if (activate_status == 0) { // 如果为0，则为未激活，再判断广播
if (action.equals(ACTION_BOOT)) { //
// 开机广播 （）
preferences.edit().putInt(IS_OPEN_FLAG, 0).commit();
if (net_status) { // 如果网络可用，就进入激活界面
Intent startIntent = new Intent(context, MainActivity.class);
startIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
context.startActivity(startIntent);
preferences.edit().putInt(IS_OPEN_FLAG, 1).commit(); // 若启动过，将标志位设置为true，以后就不启动了
} else {
// 网络不可用，就什么也不做，就是不进入激活界面
}
} else if (action.equals(ACTION_SETTING)) { // settings的广播
// 启动广播，首先取得激活状态值
if (net_status) { // 如果网络可用，就进入激活界面
Intent startIntent = new Intent(context, MainActivity.class);
startIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
context.startActivity(startIntent);
preferences.edit().putInt(IS_OPEN_FLAG, 1).commit();
} else {
// 网络不可用，就什么也不做，就是不进入激活界面
}
} else { // 网络状态的改变的广播
if (preferences.getInt(IS_OPEN_FLAG, 0) == 0) { // 如果未启动过，就判断，在启动。(（）
ConnectivityManager connectivityManager = (ConnectivityManager) context
.getSystemService(Context.CONNECTIVITY_SERVICE);
if (connectivityManager != null) {
NetworkInfo[] networkInfos = connectivityManager
.getAllNetworkInfo();
for (int i = 0; i < networkInfos.length; i++) {
State state = networkInfos[i].getState();
if (NetworkInfo.State.CONNECTED == state) {
Intent startIntent = new Intent(context,
MainActivity.class);
startIntent
.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
context.startActivity(startIntent);
preferences.edit().putInt(IS_OPEN_FLAG, 1)
.commit();
return;
}
}
}
} else { // 如果已启动过，就不再启动了
}
}
} else {
}
}
/**
* 检查网络是否可用
*/
public boolean checkNetStatus(Context context) {
ConnectivityManager manager = (ConnectivityManager) context
.getSystemService(context.CONNECTIVITY_SERVICE);
NetworkInfo info = manager.getActiveNetworkInfo();
if (info != null && info.isAvailable()) {
return true;
} else {
return false;
}
}
}
其实这个类中的判断是开机发送的广播还是setting发送的广播，是没有必要的，因为他们所执行的操作是一致的。所以把判断去掉，这样不管广播是哪里发送的过来的，都会启动romact.apk。不过判断激活状态值是1还是0，这是必须的，如果是已经激活状态，就什么操作也不执行，就不会启动romact.apk。
对了，对ACTION_BOOT_COMPLETED的操作是需要加入权限的
<uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED" />写到这里，今天研究了下finish()和System.exit(0)的区别：
System.exit(0);是退出整个应用，它会杀掉应用，释放应用程序所占用的资源。
finish();只是将当前的Activity关掉，也可以说是放到后台了，整个应用程序还是运行的。打Log就会发现，finish(0)方法后面的操作依旧会执行。finish并不会释放占用的资源。
这里还用到了post方法将客户端和服务端的数据进行交互，由于这是第一次操作json数据的交互，是参考别人的代码，并不是很理解。万事开头难，最起码能看懂了。
private void sendData() {
new Thread(new Runnable() {
@Override
public void run() {
// String remcersion = JSON.toJSONString("remcersion");//
// 解析json字符串
// 把所有的json数据一个个解析出来
Log.i(TEST_TAG, "2222");
try {
HttpParams params = new BasicHttpParams();
// 超时设置
/* 从连接池中取连接的超时时间 */
ConnManagerParams.setTimeout(params, 1000);
/* 连接超时 */
HttpConnectionParams.setConnectionTimeout(params, 2000);
/* 请求超时 */
HttpConnectionParams.setSoTimeout(params, 4000);
DefaultHttpClient client = new DefaultHttpClient(params);
HttpPost post = new HttpPost(path);// post请求<span style="white-space:pre"> </span>// 这就是所谓的表单格式form
List<BasicNameValuePair> nvps = new ArrayList<BasicNameValuePair>();
nvps.add(new BasicNameValuePair("romversion",
serviceInfoMap.get("romversion")));
nvps.add(new BasicNameValuePair("brand", serviceInfoMap
.get("brand")));
nvps.add(new BasicNameValuePair("model", serviceInfoMap
.get("model")));
nvps.add(new BasicNameValuePair("device", serviceInfoMap
.get("device")));
nvps.add(new BasicNameValuePair("imei", serviceInfoMap
.get("imei")));
Log.i(TEST_TAG, nvps.toString());
// [romversion=G620S-UL00V100R001C17B262, brand=HUAWEI,
// model=G620S-UL00, device=hwG620S-UL00,
// imei=865242025001258]
// 这里就是从json中解析出来，给服务器发的参数
post.setEntity(new UrlEncodedFormEntity(nvps, HTTP.UTF_8));
// 服务器响应这里需要解析json数据，通过判断，提示成功失败
HttpResponse response = client.execute(post);
HttpEntity entity = response.getEntity();
int res = response.getStatusLine().getStatusCode();
Log.i(TEST_TAG, res + "");
if (res == 200) {
InputStream content = entity.getContent();
int len = 0;
StringBuffer sb = new StringBuffer();
byte[] buff = new byte[1024];
while ((len = content.read(buff)) != -1) {
String temp = new String(buff, 0, len);
sb.append(temp);
temp = null;
}
Log.i(TEST_TAG, sb.toString());
final JSONObject jsonObject = new JSONObject(sb
.toString());
// .optJSONObject("");
// 每500ms发送一次信息，看这个是否取到，是不是一个是""
new Thread(new Runnable() {
@Override
public void run() {
while (true) {
try {
statusValue = jsonObject
.getString("status");
} catch (JSONException e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
}
Message msg = new Message();
msg.what = 1;
msg.obj = statusValue;
mHandler.sendMessage(msg);
try {
Thread.sleep(500);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}).start();
} else {
Message msg = mHandler.obtainMessage();
msg.what = 3;// 服务器连接失败
mHandler.sendMessage(msg);
}
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
} catch (ClientProtocolException e) {
e.printStackTrace();
// mHandler.sendEmptyMessage(3);
} catch (SocketException e) {
// mHandler.sendEmptyMessage(3);
} catch (IOException e) {
// mHandler.sendEmptyMessage(3);
e.printStackTrace();
} catch (JSONException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}).start();
}如果要发送的JSON格式的字符串(不用传统的post方式发送。)
HttpPost request = new HttpPost(url);
// 先封装一个 JSON 对象
JSONObject param = new JSONObject();
param.put("name", "rarnu");
param.put("password", "123456");
// 绑定到请求 Entry
StringEntity se = new StringEntity(param.toString());
request.setEntity(se);
// 发送请求
HttpResponse httpResponse = new DefaultHttpClient().execute(request);
// 得到应答的字符串，这也是一个 JSON 格式保存的数据
String retSrc = EntityUtils.toString(httpResponse.getEntity());
// 生成 JSON 对象
JSONObject result = new JSONObject( retSrc);
String token = result.get("token"); 最终与服务器交互代码以下为标准：
private void sendData1() {
new Thread(new Runnable() {
@Override
public void run() {
Log.i(TEST_TAG, "2222");
try {
HttpPost post = new HttpPost(ACTIVATE_PATH);// post请求
// 先封装一个JSON对象
JSONObject param = new JSONObject();
param.put("romversion", serviceInfoMap.get("romversion"));
param.put("brand", serviceInfoMap.get("brand"));
param.put("model", serviceInfoMap.get("model"));
param.put("device", serviceInfoMap.get("device"));
param.put("imei", serviceInfoMap.get("imei"));
// 绑定到请求Entry
StringEntity se = new StringEntity(param.toString());
post.setEntity(se);
Log.i(TEST_TAG, "JSON为---> " + param.toString());
// JSON为--->
// {"device":"hwG620S-UL00","brand":"HUAWEI","model":"G620S-UL00","imei":"865242025001258","romversion":"G620S-UL00V100R001C17B264"}
// 发送请求
// DefaultHttpClient client = new DefaultHttpClient(params);
HttpParams params = new BasicHttpParams();
DefaultHttpClient localDefaultHttpClient = new DefaultHttpClient(
params);
localDefaultHttpClient.getParams().setParameter(
"http.connection.timeout", Integer.valueOf(30000));
localDefaultHttpClient.getParams().setParameter(
"http.socket.timeout", Integer.valueOf(30000));
HttpResponse response = localDefaultHttpClient
.execute(post);
// 得到应答的字符串，这也是一个JSON格式保存的数据
String retStr = EntityUtils.toString(response.getEntity());
// 生成JSON对象
JSONObject result = new JSONObject(retStr);
int status_value = response.getStatusLine().getStatusCode();
Log.i(TEST_TAG, "" + status_value);
String statusValue = "";
statusValue = result.getString("status");
Log.i(TEST_TAG, statusValue);
if (!statusValue.equals("")) {
// 如果不为空，说明取到了数据，然后就先关闭进去条
mLoading.dismiss();
// 然后判断值是否==1，来决定弹出哪个dialog
// 激活成功，就把值传到系统的contentprovider，然后永久保存
if (Integer.parseInt(statusValue) == 1) {
mHandler.sendEmptyMessage(SHOW_SUCCESS);
// showResultDialog(1); // 显示成功的dialog
// 将值设置成1
Settings.System.putInt(getContentResolver(),
SETTING_MODIFY_NAME, 1);
} else { // 只要是不为1外的其他值，都算失败，弹出失败的dialog
mHandler.sendEmptyMessage(SHOW_FAILURE);
// showResultDialog(0);
}
}
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
Log.i(TEST_TAG, "problem-->11111");
} catch (ClientProtocolException e) {
e.printStackTrace();
Log.i(TEST_TAG, "problem-->22222");
mHandler.sendEmptyMessage(CONTENT_STATUS);
} catch (SocketException e) {
Log.i(TEST_TAG, "problem-->33333");
mHandler.sendEmptyMessage(CONTENT_STATUS);
} catch (IOException e) {
Log.i(TEST_TAG, "problem-->44444");
mHandler.sendEmptyMessage(CONTENT_STATUS);
e.printStackTrace();
} catch (JSONException e) {
Log.i(TEST_TAG, "problem-->5555");
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}).start();
}HttpResponse response = localDefaultHttpClient.execute(post);最后才发现，计时是网络连接状态，却没有检测网络是否可用。其实是假网络。所以导致无法交互。
json参考连接：
http://blog.csdn.net/dadoneo/article/details/6233366
http://407827531.iteye.com/blog/1266217
有人还推荐我用xUtils框架，说实话，确实不会用
MainActivity.class
package com.minuzuos.romactivate;
import java.io.IOException;
import java.io.InputStream;
import java.io.UnsupportedEncodingException;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.net.SocketException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.NameValuePair;
import org.apache.http.client.ClientProtocolException;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.conn.params.ConnManagerParams;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.params.BasicHttpParams;
import org.apache.http.params.HttpConnectionParams;
import org.apache.http.params.HttpParams;
import org.apache.http.protocol.HTTP;
import org.apache.http.util.EntityUtils;
import org.json.JSONException;
import org.json.JSONObject;
import android.R.integer;
import android.app.Activity;
import android.app.AlertDialog;
import android.app.Dialog;
import android.app.AlertDialog.Builder;
import android.content.Context;
import android.content.DialogInterface;
import android.content.Intent;
import android.net.ConnectivityManager;
import android.net.NetworkInfo;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.provider.Settings;
import android.provider.Settings.SettingNotFoundException;
import android.telephony.TelephonyManager;
import android.util.Log;
import android.view.View;
import android.view.View.OnClickListener;
import android.view.Window;
import android.widget.Button;
import android.widget.TextView;
import android.widget.Toast;
public class MainActivity extends Activity implements OnClickListener {
private TextView content1;
private Button btn_activate, btn_cancel, btn_close;
// 存放手机五个信息的键值对map
public Map<String, String> serviceInfoMap = new HashMap<String, String>();
// 服务器地址
private final static String ACTIVATE_PATH = "http://www.minzuos.com/do.romactivate.php";
private final static String SETTING_MODIFY_NAME = "com.minzuos.romactivate.activate.status";
private final static String TEST_TAG = "test_pass";
private final static int CONTENT_STATUS = 3;
private final static int SHOW_SUCCESS = 5;
private final static int SHOW_FAILURE = 4;
private final static int CLOSE_DIALOG = 2;
// 初始化Dialog
public Dialog waiting = null;
Handler mHandler = new Handler() {
public void handleMessage(Message msg) {
switch (msg.what) {
case CONTENT_STATUS:
Log.i(TEST_TAG, "连接失败"); // [niejianjian15-7-20xiugai]
break;
case CLOSE_DIALOG:
waiting.dismiss();
break;
case SHOW_FAILURE:
showResultDialog(0);
break;
case SHOW_SUCCESS:
showResultDialog(1);
break;
default:
break;
}
};
};
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
// 无标题设置
requestWindowFeature(Window.FEATURE_NO_TITLE);
// 如果查询到值为1，就是已经激活，此时进入已激活界面，
// 只有值为0，就是未激活状态的情况下，才会进入激活界面
if (Settings.System
.getInt(getContentResolver(), SETTING_MODIFY_NAME, 0) == 1) {
setContentView(R.layout.activity_second);
init2();
} else {
setContentView(R.layout.activity_main);
init1();
}
Log.i(TEST_TAG, "1111");
Log.i(TEST_TAG,
""
+ Settings.System.getInt(getContentResolver(),
SETTING_MODIFY_NAME, 0));
// 一进入激活程序，就开始查询信息。
;
}
private void init2() {
btn_close = (Button) findViewById(R.id.btn_close);
btn_close.setOnClickListener(this);
}
private void init1() {
getServicesInfo();
content1 = (TextView) findViewById(R.id.content1);
content1.setText("\u3000\u3000您的设备还未激活，只有成功激活后才能正确使用本系统。"
+ "激活过程很简单，只要在联网状态下点击【激活】按钮即可。"
+ "\n\u3000\u3000激活时我们只向服务器发送手机厂家，手机型号以及系统版本等三个信息，"
+ "不包括您的个人信息，激活过程只需要做一次。"); // [niejianjian15-7-20xiugai]
btn_activate = (Button) findViewById(R.id.btn_activate);
btn_activate.setOnClickListener(this);
btn_cancel = (Button) findViewById(R.id.btn_cancel);
btn_cancel.setOnClickListener(this);
}
@Override
public void onClick(View v) {
int id = v.getId();
switch (id) {
case R.id.btn_activate:
// 激活状态是进入是就判断的，如果能出现激活按钮，自然是为激活状态，此时就无需在判断状态之，直接进行操作
// 点击激活按钮，直接进行激活操作，首先是判断网络状态，在进行可用和不可用的处理
if (checkNetStatus()) { // 判断网络状态是否可用，就开始激活动作
sendData1(); // 发送数据，取数据
showDialog();
} else { // 网络不可用，就弹窗提示设置网络
showSetNetDialog();
}
break;
case R.id.btn_cancel:
System.exit(0);
break;
case R.id.btn_close:
System.exit(0);
break;
}
}
private void showDialog() {
waiting = new Dialog(this, R.style.dialog);
waiting.setCancelable(false);
waiting.setContentView(R.layout.romacting);
waiting.show();
}
private void sendData1() {
new Thread(new Runnable() {
@Override
public void run() {
Log.i(TEST_TAG, "2222");
try {
HttpPost post = new HttpPost(ACTIVATE_PATH);// post请求
// 设置添加对象
List<NameValuePair> paramsForm = new ArrayList<NameValuePair>();
paramsForm.add(new BasicNameValuePair("romversion",
serviceInfoMap.get("romversion")));
paramsForm.add(new BasicNameValuePair("brand",
serviceInfoMap.get("brand")));
paramsForm.add(new BasicNameValuePair("model",
serviceInfoMap.get("model")));
paramsForm.add(new BasicNameValuePair("device",
serviceInfoMap.get("device")));
paramsForm.add(new BasicNameValuePair("imei",
serviceInfoMap.get("imei")));
Log.i(TEST_TAG, paramsForm.toString());
post.setEntity(new UrlEncodedFormEntity(paramsForm,
HTTP.UTF_8));
// 发送请求
HttpParams params = new BasicHttpParams();
DefaultHttpClient localDefaultHttpClient = new DefaultHttpClient(
params);
localDefaultHttpClient.getParams().setParameter(
"http.connection.timeout", Integer.valueOf(30000));
localDefaultHttpClient.getParams().setParameter(
"http.socket.timeout", Integer.valueOf(30000));
HttpResponse response = localDefaultHttpClient
.execute(post);
// 得到应答的字符串，这也是一个JSON格式保存的数据
String retStr = EntityUtils.toString(response.getEntity());
// 生成JSON对象
JSONObject result = new JSONObject(retStr);
int status_value = response.getStatusLine().getStatusCode();
Log.i(TEST_TAG, "" + status_value);
String statusValue = "";
statusValue = result.getString("status");
Log.i(TEST_TAG, "status: " + statusValue);
Log.i(TEST_TAG, "datatime: " + result.getString("datatime"));
Log.i(TEST_TAG, "message: " + result.getString("message"));
if (!statusValue.equals("")) {
// 如果不为空，说明取到了数据，然后就先关闭进去条
mHandler.sendEmptyMessage(CLOSE_DIALOG);
// 然后判断值是否==1，来决定弹出哪个dialog
// 激活成功，就把值传到系统的contentprovider，然后永久保存
if (Integer.parseInt(statusValue) == 1) {
// 将值设置成1。需要加权限
Settings.System.putInt(getContentResolver(),
SETTING_MODIFY_NAME, 1);
mHandler.sendEmptyMessage(SHOW_SUCCESS);
} else { // 只要是不为1外的其他值，都算失败，弹出失败的dialog
mHandler.sendEmptyMessage(SHOW_FAILURE);
}
}
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
mHandler.sendEmptyMessage(SHOW_FAILURE);
mHandler.sendEmptyMessage(CONTENT_STATUS);
mHandler.sendEmptyMessage(CLOSE_DIALOG);
} catch (ClientProtocolException e) {
e.printStackTrace();
mHandler.sendEmptyMessage(SHOW_FAILURE);
mHandler.sendEmptyMessage(CONTENT_STATUS);
mHandler.sendEmptyMessage(CLOSE_DIALOG);
} catch (SocketException e) {
mHandler.sendEmptyMessage(SHOW_FAILURE);
mHandler.sendEmptyMessage(CONTENT_STATUS);
mHandler.sendEmptyMessage(CLOSE_DIALOG);
} catch (IOException e) {
mHandler.sendEmptyMessage(SHOW_FAILURE);
mHandler.sendEmptyMessage(CONTENT_STATUS);
mHandler.sendEmptyMessage(CLOSE_DIALOG);
e.printStackTrace();
} catch (JSONException e) {
mHandler.sendEmptyMessage(SHOW_FAILURE);
mHandler.sendEmptyMessage(CONTENT_STATUS);
mHandler.sendEmptyMessage(CLOSE_DIALOG);
e.printStackTrace();
}
}
}).start();
}
/**
* 在联网的前提下，在还没有激活的情况下，点击激活操作的时候，不管成功与否，最后返回结果的提示框
*/
private void showResultDialog(int mm) {
if (mm == 1) { // 激活成功
AlertDialog.Builder builder = new Builder(this);
builder.setIcon(R.drawable.ic_launcher);
builder.setTitle("激活成功");
builder.setMessage("您的终端激活成功！");
builder.setPositiveButton("确定",
new DialogInterface.OnClickListener() {
@Override
public void onClick(DialogInterface dialog, int which) {
System.exit(0);
}
});
builder.show();
} else { // 激活失败
AlertDialog.Builder builder = new Builder(this);
builder.setIcon(R.drawable.ic_launcher);
builder.setTitle("激活失败");
builder.setMessage("激活失败，请重试或者检查网络设置！"); // [niejianjian15-7-20xiugai]
builder.setNegativeButton("取消",
new DialogInterface.OnClickListener() {
@Override
public void onClick(DialogInterface dialog, int which) {
dialog.dismiss();
}
});
builder.setPositiveButton("重试",
new android.content.DialogInterface.OnClickListener() {
@Override
public void onClick(DialogInterface dialog, int which) {
// 重新激活，重新发送数据，重新打开dialog
sendData1(); // 发送数据，取数据
waiting.show();
}
});
builder.show();
}
}
/**
* 检查网络是否可用
*/
public boolean checkNetStatus() {
ConnectivityManager manager = (ConnectivityManager) getSystemService(CONNECTIVITY_SERVICE);
NetworkInfo info = manager.getActiveNetworkInfo();
if (info != null && info.isAvailable()) {
return true;
} else {
return false;
}
}
/**
* 在没有联网的情况下，激活操作是无法进行的，无法判断是否已经激活， 所以会先提示用户没有联网，弹框主动让用户设置网络
*/
private void showSetNetDialog() {
// Toast.makeText(getApplicationContext(), "网络不可用", 0).show();
// [niejianjian15-7-20delete]
AlertDialog.Builder builder = new Builder(this);
builder.setTitle("网络设置");
builder.setMessage("当前无可用网络，请检查网络设置后重新激活！");
builder.setPositiveButton("设置",
new android.content.DialogInterface.OnClickListener() {
@Override
public void onClick(DialogInterface dialog, int which) {
Intent intent = new Intent(
Settings.ACTION_WIFI_SETTINGS);
startActivity(intent);
// finish();
}
});
builder.setNegativeButton("取消",
new android.content.DialogInterface.OnClickListener() {
@Override
public void onClick(DialogInterface dialog, int which) {
dialog.dismiss();
}
});
builder.show();
}
/**
* 进入应用程序，就会先获得手机的五个字段信息，然后将它们以键值对的形式，保存到map结合中，
* 然后向服务器发送数据的时候会用到，
*/
private void getServicesInfo() {
// 每次都清空集合
serviceInfoMap.clear();
// romversion:获取系统ROM版本号
// String strSystem = android.os.Build.DISPLAY;
// String strSystem = getResources().getString("ro.cm.display.version")
// ;
// String strSystem = SystemProperties.get("ro.cm.display.version",
// "aa");
// String strSystem = android.os.Build.DISPLAY;
// 想要获得系统的rom版本号，这是某个特定手机专有的一个字段。
// 此时就需要查看手机原码，找到那个字段的value，从而获得它的key值，就是ro.cm.display.version
// 然后通过调用android.os.SystemProperties类，它类似于android.Provider.Settings.System
// 但是android.os.SystemPriperties是内部隐藏类，在应用程序编写过程中是无法调用的。(安全性，如果每个人都可以调用，轻易查询系统的方法，就不好了)
// 此刻利用JNI来编写，但是这个不会，有点麻烦。
// 还有就是把手机的SDK导入本地，然后关联这个SDK，再编写
// 其实最方便的方法就是利用反射
String strSystem = getRomVersion("ro.cm.display.version");
Log.i(TEST_TAG, strSystem);
serviceInfoMap.put("romversion", strSystem);
// brand：获取手机厂商
String strPhoneBrand = android.os.Build.MANUFACTURER;
serviceInfoMap.put("brand", strPhoneBrand);
// model:获取手机型号
String strPhoneModle = android.os.Build.MODEL;
serviceInfoMap.put("model", strPhoneModle);
// device:获取手机具体型号
String strPhoneDevices = android.os.Build.DEVICE;
serviceInfoMap.put("device", strPhoneDevices);
// imei:获取手机imei手机序列号
TelephonyManager telephonyManager = (TelephonyManager) this
.getSystemService(Context.TELEPHONY_SERVICE);
String strImei = telephonyManager.getDeviceId();
serviceInfoMap.put("imei", strImei);
}
public String getRomVersion(String key) {
Class<?> clazz;
try {
clazz = Class.forName("android.os.SystemProperties");
Method method = clazz.getDeclaredMethod("get", String.class);
Log.i(TEST_TAG,
"jieguo" + (String) method.invoke(clazz.newInstance(), key));
return (String) method.invoke(clazz.newInstance(), key);
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (NoSuchMethodException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (IllegalArgumentException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
} catch (InstantiationException e) {
e.printStackTrace();
}
return "";
}
}
然后是SecondActivity.class
public class SecondActivity extends Activity {
private Button btn_close;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
requestWindowFeature(Window.FEATURE_NO_TITLE);
setContentView(R.layout.activity_second);
btn_close = (Button) findViewById(R.id.btn_close);
btn_close.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View v) {
System.exit(0);
}
});
}
@Override
public boolean onKeyDown(int keyCode, KeyEvent event) {
// 判断：按下的是返回键，同时没有重复
if (keyCode == KeyEvent.KEYCODE_BACK && event.getRepeatCount() == 0) {
// 操作，由于进入当前SecondActivity界面的可能性只有一个，就是在已经激活的情况下，
// 独立进入romact.apk。然后按下返回键，才会进入当前界面，既然已经激活，
// 按返回键就没有必要在回到上一个界面，直接退出就挺好
System.exit(0);
}
return super.onKeyDown(keyCode, event);
}
}还有就是receiver，之前已经贴了代码。
然后还有一个就是菊花加载进度条。
public class DialogUtils {
/**
* 创建自定义ProgressDialog
*/
public static Dialog createLoadingDialog(Context context) {
LayoutInflater inflater = LayoutInflater.from(context);
View v = inflater.inflate(R.layout.layout_loading_dialog, null); // 得到加载view
LinearLayout layout = (LinearLayout) v.findViewById(R.id.dialog_view); // 加载布局
Dialog loadingDialog = new Dialog(context, R.style.loading_dialog); // 创建自定义样式dialog
loadingDialog.setCancelable(false); // 不可以用"返回键"取消
loadingDialog.setContentView(layout, new LinearLayout.LayoutParams(
LinearLayout.LayoutParams.WRAP_CONTENT,
LinearLayout.LayoutParams.WRAP_CONTENT));
return loadingDialog;
}
}
参考博客：
Android利用广播监听设备网络连接(断网)的变化情况 ：http://www.open-open.com/lib/view/open1379302453943.html
1169
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
