Android integrated native wechat authorization to obtain user information login
What I use in the project is to click a button to initiate wechat authorization request. First, determine whether to install wechat. If wechat is installed, authorize users. After the authorization is successful, obtain user information such as openID through the interface provided by wechat, and then do your own business:
1. To log in using wechat on Android, you must create an APP on wechat development platform and approve it to get the appid and secret
2. Rely on wechat SDK
dependencies {
compile 'com.tencent.mm.opensdk:wechat-sdk-android-without-mta:+'
}
3. Add permission
<uses-permission android:name="android.permission.INTERNET"/>
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE"/>
<uses-permission android:name="android.permission.ACCESS_WIFI_STATE"/>
<uses-permission android:name="android.permission.READ_PHONE_STATE"/>
<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/> 4. Register to wechat
iwxapi = WXAPIFactory.createWXAPI(this, Constant.APP_ID, true);
iwxapi.registerApp(Constant.APP_ID);5. Determine whether wechat is installed, and initiate authorization request if it is installed
if (!iwxapi.isWXAppInstalled()) {
Intent intent = new Intent(this, MyDialogActivity.class);
startActivity(intent);
} else {
final SendAuth.Req req = new SendAuth.Req();
req.scope = "snsapi_userinfo";
req.state = "wechat_sdk_demo_test";
iwxapi.sendReq(req);
}6. Create wxapi package and WXEntryActivity class (inherit Activity and implement IWXAPIEventHandler interface) under the package name. WXEntryActivity is a class of wechat callback, which usually gives a transparent topic or finish es processing business logic directly. You need to get the code in the callback, then get the AccessToken according to the code, and then get the UserInfo according to the AccessToken and OpenId.
The code is as follows:
public class WXEntryActivity extends AppCompatActivity implements IWXAPIEventHandler {
private IWXAPI iwxapi;
private String unionid;
private String openid;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
getSupportActionBar().hide();
// //Hide status bar
getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN,
WindowManager.LayoutParams.FLAG_FULLSCREEN);
//Receive the handle intent method of sharing and login, and process the result
iwxapi = WXAPIFactory.createWXAPI(this, Constant.APP_ID, false);
iwxapi.handleIntent(getIntent(), this);
}
@Override
public void onReq(BaseReq baseReq) {
}
//Request callback result processing
@Override
public void onResp(BaseResp baseResp) {
//Login callback
switch (baseResp.errCode) {
case BaseResp.ErrCode.ERR_OK:
String code = ((SendAuth.Resp) baseResp).code;
//Get user information
getAccessToken(code);
break;
case BaseResp.ErrCode.ERR_AUTH_DENIED://User denied authorization
finish();
break;
case BaseResp.ErrCode.ERR_USER_CANCEL://User cancelled
finish();
break;
default:
finish();
break;
}
}
private void getAccessToken(String code) {
//Get authorization
StringBuffer loginUrl = new StringBuffer();
loginUrl.append("https://api.weixin.qq.com/sns/oauth2/access_token")
.append("?appid=")
.append(Constant.APP_ID)
.append("&secret=")
.append(Constant.SECRET)
.append("&code=")
.append(code)
.append("&grant_type=authorization_code");
OkHttpUtils.ResultCallback<String> resultCallback = new OkHttpUtils.ResultCallback<String>() {
@Override
public void onSuccess(String response) {
String access = null;
String openId = null;
try {
JSONObject jsonObject = new JSONObject(response);
access = jsonObject.getString("access_token");
openId = jsonObject.getString("openid");
} catch (JSONException e) {
e.printStackTrace();
}
//Access to personal information
String getUserInfo = "https://api.weixin.qq.com/sns/userinfo?access_token=" + access + "&openid=" + openId;
OkHttpUtils.ResultCallback<String> reCallback = new OkHttpUtils.ResultCallback<String>() {
@Override
public void onSuccess(String responses) {
String nickName = null;
String sex = null;
String city = null;
String province = null;
String country = null;
String headimgurl = null;
try {
JSONObject jsonObject = new JSONObject(responses);
openid = jsonObject.getString("openid");
nickName = jsonObject.getString("nickname");
sex = jsonObject.getString("sex");
city = jsonObject.getString("city");
province = jsonObject.getString("province");
country = jsonObject.getString("country");
headimgurl = jsonObject.getString("headimgurl");
unionid = jsonObject.getString("unionid");
loadNetData(1, openid, nickName, sex, province,
city, country, headimgurl, unionid);
} catch (JSONException e) {
e.printStackTrace();
}
}
@Override
public void onFailure(Exception e) {
Toast.makeText(WXEntryActivity.this, "Login failed", Toast.LENGTH_SHORT).show();
finish();
}
};
OkHttpUtils.get(getUserInfo, reCallback);
}
@Override
public void onFailure(Exception e) {
Toast.makeText(WXEntryActivity.this, "Login failed", Toast.LENGTH_SHORT).show();
finish();
}
};
OkHttpUtils.get(loginUrl.toString(), resultCallback);
}
@Override
protected void onPause() {
overridePendingTransition(0, 0);
super.onPause();
}
}The code of OkHttpUtils is pasted here for your convenience:
public class OkHttpUtils {
private static OkHttpUtils mInstance;
private OkHttpClient mOkHttpClient;
private Handler mDelivery;
private Gson mGson;
private OkHttpUtils() {
mOkHttpClient = new OkHttpClient.Builder()
.connectTimeout(10, TimeUnit.SECONDS)
.writeTimeout(10, TimeUnit.SECONDS)
.readTimeout(30, TimeUnit.SECONDS)
.build();
mGson = new Gson();
mDelivery = new Handler(Looper.getMainLooper());
}
private synchronized static OkHttpUtils getmInstance() {
if (mInstance == null) {
mInstance = new OkHttpUtils();
}
return mInstance;
}
private void getRequest(String url, final ResultCallback callback) {
final Request request = new Request.Builder().url(url).build();
deliveryResult(callback, request);
}
private void postRequest(String url, final ResultCallback callback, List<Param> params) {
Request request = buildPostRequest(url, params);
deliveryResult(callback, request);
}
/**
* Processing result
* @param callback
* @param request
*/
private void deliveryResult(final ResultCallback callback, Request request) {
mOkHttpClient.newCall(request).enqueue(new Callback() {
@Override
public void onFailure(Call call, IOException e) {
sendFailCallback(callback, e);
}
@Override
public void onResponse(Call call, Response response) throws IOException {
try {
String str = response.body().string();
if (callback.mType == String.class) {
/**
* Return string
*/
sendSuccessCallBack(callback, str);
} else {
/**
* Here we deal with parsing return objects
*/
Object object = mGson.fromJson(str, callback.mType);
sendSuccessCallBack(callback, object);
}
} catch (final Exception e) {
// LogUtils.e(TAG, "convert json failure", e);
sendFailCallback(callback, e);
}
}
});
}
private void sendFailCallback(final ResultCallback callback, final Exception e) {
mDelivery.post(new Runnable() {
@Override
public void run() {
if (callback != null) {
callback.onFailure(e);
}
}
});
}
private void sendSuccessCallBack(final ResultCallback callback, final Object obj) {
mDelivery.post(new Runnable() {
@Override
public void run() {
if (callback != null) {
callback.onSuccess(obj);
}
}
});
}
private Request buildPostRequest(String url, List<Param> params) {
FormBody.Builder builder= new FormBody.Builder();
for (Param param : params) {
builder.add(param.key, param.value);
}
RequestBody requestBody = builder.build();
return new Request.Builder().url(url).post(requestBody).build();
}
/**********************External interface************************/
/**
* get request
* @param url Request url
* @param callback Request callback
*/
public static void get(String url, ResultCallback callback) {
getmInstance().getRequest(url, callback);
}
/**
* post request
* @param url Request url
* @param callback Request callback
* @param params Request parameters
*/
public static void post(String url, final ResultCallback callback, List<Param> params) {
getmInstance().postRequest(url, callback, params);
}
/**
* http Request callback class, callback method is executed in UI thread
* @param <T>
*/
public static abstract class ResultCallback<T> {
Type mType;
public ResultCallback(){
mType = getSuperclassTypeParameter(getClass());
}
static Type getSuperclassTypeParameter(Class<?> subclass) {
Type superclass = subclass.getGenericSuperclass();
if (superclass instanceof Class) {
throw new RuntimeException("Missing type parameter.");
}
ParameterizedType parameterized = (ParameterizedType) superclass;
return $Gson$Types.canonicalize(parameterized.getActualTypeArguments()[0]);
}
/**
* Request successful callback
* @param response
*/
public abstract void onSuccess(T response);
/**
* Request failed callback
* @param e
*/
public abstract void onFailure(Exception e);
}
/**
* post The request parameter class can be extracted into generics according to the project
*/
public static class Param {
String key;
String value;
public Param() {
}
public Param(String key, String value) {
this.key = key;
this.value = value;
}
}
}This login authorization is over