(16);
245 | }
246 | if (mFloatWindowMap.containsKey(mTag)) {
247 | throw new IllegalArgumentException(
248 | "FloatWindow of this tag has been added, Please set a new tag for the new FloatWindow");
249 | }
250 | if (mView == null && mLayoutId == 0) {
251 | throw new IllegalArgumentException("View has not been set!");
252 | }
253 | if (mView == null) {
254 | mView = ViewUtils.inflate(mApplicationContext, mLayoutId);
255 | }
256 | BaseFloatWindow floatWindowImpl = new IFloatWindowImpl(this);
257 | mFloatWindowMap.put(mTag, floatWindowImpl);
258 |
259 | L.i("build [" + mTag + "] success. sdk version:" + FwContent.VERSION);
260 | }
261 | }
262 | }
263 |
--------------------------------------------------------------------------------
/floatwindow/src/com/yhao/floatwindow/utils/RefInvoke.java:
--------------------------------------------------------------------------------
1 | package com.yhao.floatwindow.utils;
2 |
3 |
4 | import android.os.Build;
5 |
6 | import java.lang.reflect.Constructor;
7 | import java.lang.reflect.Field;
8 | import java.lang.reflect.Method;
9 |
10 | /**
11 | * @Copyright © 2019 sanbo Inc. All rights reserved.
12 | * @Description: TODO
13 | * @Version: 1.0
14 | * @Create: 2019-12-11 15:34
15 | * @author: sanbo
16 | */
17 | public class RefInvoke {
18 | private static Object sVmRuntime;
19 | private static Method setHiddenApiExemptions;
20 |
21 | static {
22 | if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
23 | try {
24 | Method forName = Class.class.getDeclaredMethod("forName", String.class);
25 | Method getDeclaredMethod = Class.class.getDeclaredMethod("getDeclaredMethod", String.class, Class[].class);
26 |
27 | Class vmRuntimeClass = (Class) forName.invoke(null, "dalvik.system.VMRuntime");
28 | Method getRuntime = (Method) getDeclaredMethod.invoke(vmRuntimeClass, "getRuntime", null);
29 | setHiddenApiExemptions = (Method) getDeclaredMethod.invoke(vmRuntimeClass, "setHiddenApiExemptions", new Class[]{String[].class});
30 | sVmRuntime = getRuntime.invoke(null);
31 | setHiddenApiExemptions.invoke(sVmRuntime, new Object[]{new String[]{"L"}});
32 | } catch (Throwable e) {
33 | }
34 | }
35 |
36 | }
37 |
38 | //无参
39 | public static Object createObject(String className) {
40 | Class[] pareTyples = new Class[]{};
41 | Object[] pareVaules = new Object[]{};
42 |
43 | try {
44 | Class r = Class.forName(className);
45 | return createObject(r, pareTyples, pareVaules);
46 | } catch (ClassNotFoundException e) {
47 | e.printStackTrace();
48 | }
49 |
50 | return null;
51 | }
52 |
53 | //无参
54 | public static Object createObject(Class clazz) {
55 | Class[] pareTyple = new Class[]{};
56 | Object[] pareVaules = new Object[]{};
57 |
58 | return createObject(clazz, pareTyple, pareVaules);
59 | }
60 |
61 | //一个参数
62 | public static Object createObject(String className, Class pareTyple, Object pareVaule) {
63 | Class[] pareTyples = new Class[]{pareTyple};
64 | Object[] pareVaules = new Object[]{pareVaule};
65 |
66 | try {
67 | Class r = Class.forName(className);
68 | return createObject(r, pareTyples, pareVaules);
69 | } catch (ClassNotFoundException e) {
70 | e.printStackTrace();
71 | }
72 |
73 | return null;
74 | }
75 |
76 | //一个参数
77 | public static Object createObject(Class clazz, Class pareTyple, Object pareVaule) {
78 | Class[] pareTyples = new Class[]{pareTyple};
79 | Object[] pareVaules = new Object[]{pareVaule};
80 |
81 | return createObject(clazz, pareTyples, pareVaules);
82 | }
83 |
84 | //多个参数
85 | public static Object createObject(String className, Class[] pareTyples, Object[] pareVaules) {
86 | try {
87 | Class r = Class.forName(className);
88 | return createObject(r, pareTyples, pareVaules);
89 | } catch (ClassNotFoundException e) {
90 | e.printStackTrace();
91 | }
92 |
93 | return null;
94 | }
95 |
96 | //多个参数
97 | public static Object createObject(Class clazz, Class[] pareTyples, Object[] pareVaules) {
98 | try {
99 | Constructor ctor = clazz.getDeclaredConstructor(pareTyples);
100 | ctor.setAccessible(true);
101 | return ctor.newInstance(pareVaules);
102 | } catch (Exception e) {
103 | e.printStackTrace();
104 | }
105 |
106 | return null;
107 | }
108 |
109 |
110 | //多个参数
111 | public static Object invokeInstanceMethod(Object obj, String methodName, Class[] pareTyples, Object[] pareVaules) {
112 | if (obj == null) {
113 | return null;
114 | }
115 |
116 | try {
117 | //调用一个private方法
118 | Method method = obj.getClass().getDeclaredMethod(methodName, pareTyples); //在指定类中获取指定的方法
119 | method.setAccessible(true);
120 | return method.invoke(obj, pareVaules);
121 |
122 | } catch (Exception e) {
123 | e.printStackTrace();
124 | }
125 |
126 | return null;
127 | }
128 |
129 | //一个参数
130 | public static Object invokeInstanceMethod(Object obj, String methodName, Class pareTyple, Object pareVaule) {
131 | Class[] pareTyples = {pareTyple};
132 | Object[] pareVaules = {pareVaule};
133 |
134 | return invokeInstanceMethod(obj, methodName, pareTyples, pareVaules);
135 | }
136 |
137 | //无参
138 | public static Object invokeInstanceMethod(Object obj, String methodName) {
139 | Class[] pareTyples = new Class[]{};
140 | Object[] pareVaules = new Object[]{};
141 |
142 | return invokeInstanceMethod(obj, methodName, pareTyples, pareVaules);
143 | }
144 |
145 |
146 | //无参
147 | public static Object invokeStaticMethod(String className, String method_name) {
148 | Class[] pareTyples = new Class[]{};
149 | Object[] pareVaules = new Object[]{};
150 |
151 | return invokeStaticMethod(className, method_name, pareTyples, pareVaules);
152 | }
153 |
154 | //一个参数
155 | public static Object invokeStaticMethod(String className, String method_name, Class pareTyple, Object pareVaule) {
156 | Class[] pareTyples = new Class[]{pareTyple};
157 | Object[] pareVaules = new Object[]{pareVaule};
158 |
159 | return invokeStaticMethod(className, method_name, pareTyples, pareVaules);
160 | }
161 |
162 | //多个参数
163 | public static Object invokeStaticMethod(String className, String method_name, Class[] pareTyples, Object[] pareVaules) {
164 | try {
165 | Class obj_class = Class.forName(className);
166 | return invokeStaticMethod(obj_class, method_name, pareTyples, pareVaules);
167 | } catch (Exception e) {
168 | e.printStackTrace();
169 | }
170 |
171 | return null;
172 | }
173 |
174 | public static Method getMethod(Object obj, String methodName, Class... pareTyples) {
175 | try {
176 | return getMethod(obj.getClass(), methodName, pareTyples);
177 | } catch (Exception e) {
178 | e.printStackTrace();
179 | }
180 | return null;
181 | }
182 |
183 | public static Method getMethod(Class clazz, String methodName, Class... pareTyples) {
184 | try {
185 | Method method = clazz.getDeclaredMethod(methodName, pareTyples);
186 | if (method == null) {
187 | method = clazz.getMethod(methodName, pareTyples);
188 | }
189 | if (method != null) {
190 | method.setAccessible(true);
191 | return method;
192 | }
193 | } catch (Exception e) {
194 | e.printStackTrace();
195 | }
196 | return null;
197 | }
198 |
199 |
200 | //无参
201 | public static Object invokeStaticMethod(Class clazz, String method_name) {
202 | Class[] pareTyples = new Class[]{};
203 | Object[] pareVaules = new Object[]{};
204 |
205 | return invokeStaticMethod(clazz, method_name, pareTyples, pareVaules);
206 | }
207 |
208 | //一个参数
209 | public static Object invokeStaticMethod(Class clazz, String method_name, Class classType, Object pareVaule) {
210 | Class[] classTypes = new Class[]{classType};
211 | Object[] pareVaules = new Object[]{pareVaule};
212 |
213 | return invokeStaticMethod(clazz, method_name, classTypes, pareVaules);
214 | }
215 |
216 | //多个参数
217 | public static Object invokeStaticMethod(Class clazz, String method_name, Class[] pareTyples, Object[] pareVaules) {
218 | try {
219 | Method method = clazz.getDeclaredMethod(method_name, pareTyples);
220 | method.setAccessible(true);
221 | return method.invoke(null, pareVaules);
222 | } catch (Exception e) {
223 | e.printStackTrace();
224 | }
225 | return null;
226 | }
227 |
228 |
229 | //简写版本
230 | public static Object getFieldObject(Object obj, String filedName) {
231 | return getFieldObject(obj.getClass(), obj, filedName);
232 | }
233 |
234 | public static Object getFieldObject(String className, Object obj, String filedName) {
235 | try {
236 | Class obj_class = Class.forName(className);
237 | return getFieldObject(obj_class, obj, filedName);
238 | } catch (ClassNotFoundException e) {
239 | e.printStackTrace();
240 | }
241 | return null;
242 | }
243 |
244 | public static Object getFieldObject(Class clazz, Object obj, String filedName) {
245 | try {
246 | Field field = clazz.getDeclaredField(filedName);
247 | field.setAccessible(true);
248 | return field.get(obj);
249 | } catch (Exception e) {
250 | e.printStackTrace();
251 | }
252 |
253 | return null;
254 | }
255 |
256 | //简写版本
257 | public static void setFieldObject(Object obj, String filedName, Object filedVaule) {
258 | setFieldObject(obj.getClass(), obj, filedName, filedVaule);
259 | }
260 |
261 | public static void setFieldObject(Class clazz, Object obj, String filedName, Object filedVaule) {
262 | try {
263 | Field field = clazz.getDeclaredField(filedName);
264 | field.setAccessible(true);
265 | field.set(obj, filedVaule);
266 | } catch (Exception e) {
267 | e.printStackTrace();
268 | }
269 | }
270 |
271 | public static void setFieldObject(String className, Object obj, String filedName, Object filedVaule) {
272 | try {
273 | Class obj_class = Class.forName(className);
274 | setFieldObject(obj_class, obj, filedName, filedVaule);
275 | } catch (ClassNotFoundException e) {
276 | e.printStackTrace();
277 | }
278 | }
279 |
280 |
281 | public static Object getStaticFieldObject(String className, String filedName) {
282 | return getFieldObject(className, null, filedName);
283 | }
284 |
285 | public static Object getStaticFieldObject(Class clazz, String filedName) {
286 | return getFieldObject(clazz, null, filedName);
287 | }
288 |
289 | public static void setStaticFieldObject(String classname, String filedName, Object filedVaule) {
290 | setFieldObject(classname, null, filedName, filedVaule);
291 | }
292 |
293 | public static void setStaticFieldObject(Class clazz, String filedName, Object filedVaule) {
294 | setFieldObject(clazz, null, filedName, filedVaule);
295 | }
296 | }
--------------------------------------------------------------------------------
/LICENSE.txt:
--------------------------------------------------------------------------------
1 | Apache License
2 | Version 2.0, January 2004
3 | http://www.apache.org/licenses/
4 |
5 | TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
6 |
7 | 1. Definitions.
8 |
9 | "License" shall mean the terms and conditions for use, reproduction,
10 | and distribution as defined by Sections 1 through 9 of this document.
11 |
12 | "Licensor" shall mean the copyright owner or entity authorized by
13 | the copyright owner that is granting the License.
14 |
15 | "Legal Entity" shall mean the union of the acting entity and all
16 | other entities that control, are controlled by, or are under common
17 | control with that entity. For the purposes of this definition,
18 | "control" means (i) the power, direct or indirect, to cause the
19 | direction or management of such entity, whether by contract or
20 | otherwise, or (ii) ownership of fifty percent (50%) or more of the
21 | outstanding shares, or (iii) beneficial ownership of such entity.
22 |
23 | "You" (or "Your") shall mean an individual or Legal Entity
24 | exercising permissions granted by this License.
25 |
26 | "Source" form shall mean the preferred form for making modifications,
27 | including but not limited to software source code, documentation
28 | source, and configuration files.
29 |
30 | "Object" form shall mean any form resulting from mechanical
31 | transformation or translation of a Source form, including but
32 | not limited to compiled object code, generated documentation,
33 | and conversions to other media types.
34 |
35 | "Work" shall mean the work of authorship, whether in Source or
36 | Object form, made available under the License, as indicated by a
37 | copyright notice that is included in or attached to the work
38 | (an example is provided in the Appendix below).
39 |
40 | "Derivative Works" shall mean any work, whether in Source or Object
41 | form, that is based on (or derived from) the Work and for which the
42 | editorial revisions, annotations, elaborations, or other modifications
43 | represent, as a whole, an original work of authorship. For the purposes
44 | of this License, Derivative Works shall not include works that remain
45 | separable from, or merely link (or bind by name) to the interfaces of,
46 | the Work and Derivative Works thereof.
47 |
48 | "Contribution" shall mean any work of authorship, including
49 | the original version of the Work and any modifications or additions
50 | to that Work or Derivative Works thereof, that is intentionally
51 | submitted to Licensor for inclusion in the Work by the copyright owner
52 | or by an individual or Legal Entity authorized to submit on behalf of
53 | the copyright owner. For the purposes of this definition, "submitted"
54 | means any form of electronic, verbal, or written communication sent
55 | to the Licensor or its representatives, including but not limited to
56 | communication on electronic mailing lists, source code control systems,
57 | and issue tracking systems that are managed by, or on behalf of, the
58 | Licensor for the purpose of discussing and improving the Work, but
59 | excluding communication that is conspicuously marked or otherwise
60 | designated in writing by the copyright owner as "Not a Contribution."
61 |
62 | "Contributor" shall mean Licensor and any individual or Legal Entity
63 | on behalf of whom a Contribution has been received by Licensor and
64 | subsequently incorporated within the Work.
65 |
66 | 2. Grant of Copyright License. Subject to the terms and conditions of
67 | this License, each Contributor hereby grants to You a perpetual,
68 | worldwide, non-exclusive, no-charge, royalty-free, irrevocable
69 | copyright license to reproduce, prepare Derivative Works of,
70 | publicly display, publicly perform, sublicense, and distribute the
71 | Work and such Derivative Works in Source or Object form.
72 |
73 | 3. Grant of Patent License. Subject to the terms and conditions of
74 | this License, each Contributor hereby grants to You a perpetual,
75 | worldwide, non-exclusive, no-charge, royalty-free, irrevocable
76 | (except as stated in this section) patent license to make, have made,
77 | use, offer to sell, sell, import, and otherwise transfer the Work,
78 | where such license applies only to those patent claims licensable
79 | by such Contributor that are necessarily infringed by their
80 | Contribution(s) alone or by combination of their Contribution(s)
81 | with the Work to which such Contribution(s) was submitted. If You
82 | institute patent litigation against any entity (including a
83 | cross-claim or counterclaim in a lawsuit) alleging that the Work
84 | or a Contribution incorporated within the Work constitutes direct
85 | or contributory patent infringement, then any patent licenses
86 | granted to You under this License for that Work shall terminate
87 | as of the date such litigation is filed.
88 |
89 | 4. Redistribution. You may reproduce and distribute copies of the
90 | Work or Derivative Works thereof in any medium, with or without
91 | modifications, and in Source or Object form, provided that You
92 | meet the following conditions:
93 |
94 | (a) You must give any other recipients of the Work or
95 | Derivative Works a copy of this License; and
96 |
97 | (b) You must cause any modified files to carry prominent notices
98 | stating that You changed the files; and
99 |
100 | (c) You must retain, in the Source form of any Derivative Works
101 | that You distribute, all copyright, patent, trademark, and
102 | attribution notices from the Source form of the Work,
103 | excluding those notices that do not pertain to any part of
104 | the Derivative Works; and
105 |
106 | (d) If the Work includes a "NOTICE" text file as part of its
107 | distribution, then any Derivative Works that You distribute must
108 | include a readable copy of the attribution notices contained
109 | within such NOTICE file, excluding those notices that do not
110 | pertain to any part of the Derivative Works, in at least one
111 | of the following places: within a NOTICE text file distributed
112 | as part of the Derivative Works; within the Source form or
113 | documentation, if provided along with the Derivative Works; or,
114 | within a display generated by the Derivative Works, if and
115 | wherever such third-party notices normally appear. The contents
116 | of the NOTICE file are for informational purposes only and
117 | do not modify the License. You may add Your own attribution
118 | notices within Derivative Works that You distribute, alongside
119 | or as an addendum to the NOTICE text from the Work, provided
120 | that such additional attribution notices cannot be construed
121 | as modifying the License.
122 |
123 | You may add Your own copyright statement to Your modifications and
124 | may provide additional or different license terms and conditions
125 | for use, reproduction, or distribution of Your modifications, or
126 | for any such Derivative Works as a whole, provided Your use,
127 | reproduction, and distribution of the Work otherwise complies with
128 | the conditions stated in this License.
129 |
130 | 5. Submission of Contributions. Unless You explicitly state otherwise,
131 | any Contribution intentionally submitted for inclusion in the Work
132 | by You to the Licensor shall be under the terms and conditions of
133 | this License, without any additional terms or conditions.
134 | Notwithstanding the above, nothing herein shall supersede or modify
135 | the terms of any separate license agreement you may have executed
136 | with Licensor regarding such Contributions.
137 |
138 | 6. Trademarks. This License does not grant permission to use the trade
139 | names, trademarks, service marks, or product names of the Licensor,
140 | except as required for reasonable and customary use in describing the
141 | origin of the Work and reproducing the content of the NOTICE file.
142 |
143 | 7. Disclaimer of Warranty. Unless required by applicable law or
144 | agreed to in writing, Licensor provides the Work (and each
145 | Contributor provides its Contributions) on an "AS IS" BASIS,
146 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
147 | implied, including, without limitation, any warranties or conditions
148 | of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
149 | PARTICULAR PURPOSE. You are solely responsible for determining the
150 | appropriateness of using or redistributing the Work and assume any
151 | risks associated with Your exercise of permissions under this License.
152 |
153 | 8. Limitation of Liability. In no event and under no legal theory,
154 | whether in tort (including negligence), contract, or otherwise,
155 | unless required by applicable law (such as deliberate and grossly
156 | negligent acts) or agreed to in writing, shall any Contributor be
157 | liable to You for damages, including any direct, indirect, special,
158 | incidental, or consequential damages of any character arising as a
159 | result of this License or out of the use or inability to use the
160 | Work (including but not limited to damages for loss of goodwill,
161 | work stoppage, computer failure or malfunction, or any and all
162 | other commercial damages or losses), even if such Contributor
163 | has been advised of the possibility of such damages.
164 |
165 | 9. Accepting Warranty or Additional Liability. While redistributing
166 | the Work or Derivative Works thereof, You may choose to offer,
167 | and charge a fee for, acceptance of support, warranty, indemnity,
168 | or other liability obligations and/or rights consistent with this
169 | License. However, in accepting such obligations, You may act only
170 | on Your own behalf and on Your sole responsibility, not on behalf
171 | of any other Contributor, and only if You agree to indemnify,
172 | defend, and hold each Contributor harmless for any liability
173 | incurred by, or claims asserted against, such Contributor by reason
174 | of your accepting any such warranty or additional liability.
175 |
176 | END OF TERMS AND CONDITIONS
177 |
178 | APPENDIX: How to apply the Apache License to your work.
179 |
180 | To apply the Apache License to your work, attach the following
181 | boilerplate notice, with the fields enclosed by brackets "{}"
182 | replaced with your own identifying information. (Don't include
183 | the brackets!) The text should be enclosed in the appropriate
184 | comment syntax for the file format. We also recommend that a
185 | file or class name and description of purpose be included on the
186 | same "printed page" as the copyright notice for easier
187 | identification within third-party archives.
188 |
189 | Copyright 2017 Wang YingHao
190 |
191 | Licensed under the Apache License, Version 2.0 (the "License");
192 | you may not use this file except in compliance with the License.
193 | You may obtain a copy of the License at
194 |
195 | http://www.apache.org/licenses/LICENSE-2.0
196 |
197 | Unless required by applicable law or agreed to in writing, software
198 | distributed under the License is distributed on an "AS IS" BASIS,
199 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
200 | See the License for the specific language governing permissions and
201 | limitations under the License.
202 |
203 |
--------------------------------------------------------------------------------
/floatwindow/src/com/yhao/floatwindow/impl/IFloatWindowImpl.java:
--------------------------------------------------------------------------------
1 | package com.yhao.floatwindow.impl;
2 |
3 | import android.animation.Animator;
4 | import android.animation.AnimatorListenerAdapter;
5 | import android.animation.ObjectAnimator;
6 | import android.animation.PropertyValuesHolder;
7 | import android.animation.TimeInterpolator;
8 | import android.animation.ValueAnimator;
9 | import android.annotation.SuppressLint;
10 | import android.os.Build;
11 | import android.view.MotionEvent;
12 | import android.view.View;
13 | import android.view.ViewConfiguration;
14 | import android.view.animation.DecelerateInterpolator;
15 |
16 | import com.yhao.floatwindow.FloatWindow;
17 | import com.yhao.floatwindow.enums.EMoveType;
18 | import com.yhao.floatwindow.enums.EScreen;
19 | import com.yhao.floatwindow.enums.ETypeRotateChange;
20 | import com.yhao.floatwindow.interfaces.BaseFloatView;
21 | import com.yhao.floatwindow.interfaces.BaseFloatWindow;
22 | import com.yhao.floatwindow.interfaces.IConfigChanged;
23 | import com.yhao.floatwindow.interfaces.ISensorRotateChanged;
24 | import com.yhao.floatwindow.interfaces.LifecycleListener;
25 | import com.yhao.floatwindow.utils.FwContent;
26 | import com.yhao.floatwindow.utils.L;
27 | import com.yhao.floatwindow.utils.RotateUtil;
28 | import com.yhao.floatwindow.utils.ViewUtils;
29 |
30 | /**
31 | * @Copyright © 2017 Analysys Inc. All rights reserved.
32 | * @Description:
33 | * @Version: 1.0.9
34 | * @Create: 2017/12/29 17:15:35
35 | * @Author: yhao
36 | * @Modify: sanbo
37 | */
38 | public class IFloatWindowImpl extends BaseFloatWindow {
39 |
40 | private FloatWindow.Builder mBuilder;
41 | private BaseFloatView mFloatView;
42 | private FloatLifecycleReceiver mFloatLifecycle;
43 | private boolean isShow;
44 | private boolean once = true;
45 | private ValueAnimator mAnimator;
46 | private TimeInterpolator mDecelerateInterpolator;
47 | private float downX;
48 | private float downY;
49 | private float upX;
50 | private float upY;
51 | private boolean mClick = false;
52 | private int mSlop;
53 | private int screenWidth, screenHeight;
54 | // 返回桌面
55 | private boolean isBackToDesktop = false;
56 |
57 | @SuppressWarnings("unused")
58 | private IFloatWindowImpl() {
59 | }
60 |
61 | public IFloatWindowImpl(FloatWindow.Builder b) {
62 | if (b == null) {
63 | return;
64 | }
65 | mBuilder = b;
66 | checkScreenSize();
67 |
68 | if (mBuilder.mMoveType == EMoveType.FIXED) {
69 | if (Build.VERSION.SDK_INT >= 25) {
70 | mFloatView = new FloatPhone(b.mApplicationContext, mBuilder.mPermissionListener);
71 | } else {
72 | mFloatView = new FloatToast(b.mApplicationContext);
73 | }
74 | } else {
75 | mFloatView = new FloatPhone(b.mApplicationContext, mBuilder.mPermissionListener);
76 | initTouchEvent();
77 | }
78 | mFloatView.setSize(mBuilder.mWidth, mBuilder.mHeight);
79 | mFloatView.setGravity(mBuilder.gravity, mBuilder.xOffset, mBuilder.yOffset);
80 | mFloatView.setView(mBuilder.mView);
81 | mFloatLifecycle = new FloatLifecycleReceiver(mBuilder.mApplicationContext, mBuilder.mShow, mBuilder.mActivities,
82 | new LifecycleListener() {
83 | // new FloatLifecycleReceiver(mBuilder.mApplicationContext, mBuilder.mShow, mBuilder.mActivities,
84 | // new LifecycleListener() {
85 | @Override
86 | public void onShow() {
87 | // show();
88 | }
89 |
90 | @Override
91 | public void onHide() {
92 | // hide();
93 | }
94 |
95 | @Override
96 | public void onBackToDesktop() {
97 | if (!mBuilder.mDesktopShow) {
98 | hide();
99 | }
100 | if (mBuilder.mViewStateListener != null) {
101 | mBuilder.mViewStateListener.onBackToDesktop();
102 | }
103 | }
104 | });
105 |
106 | if (mBuilder != null && mBuilder.isAutoRotate) {
107 | if (mFloatLifecycle != null) {
108 | mFloatLifecycle.setConfigChanged(new IConfigChanged() {
109 | @Override
110 | public void onActivityConfigChanged() {
111 | onPhoneConfigChanged(ETypeRotateChange.T_ACTIVITY_ROTATE);
112 | }
113 |
114 | @Override
115 | public void onBackToDesktop(boolean isBack) {
116 | isBackToDesktop = isBack;
117 | }
118 | });
119 | }
120 |
121 | RotateUtil.getInstance().setRotateChanged(new ISensorRotateChanged() {
122 | @Override
123 | public void onRotateChanged() {
124 | onPhoneConfigChanged(ETypeRotateChange.T_SENSOR_ROTATE);
125 | }
126 | });
127 | }
128 |
129 | }
130 |
131 |
132 | /**
133 | * 旋转时操作，处理方式:
134 | * 1. 更新页面的尺寸
135 | * 2. 矫正组件到可见区域.暂时不会按照屏幕等比例移动(如竖屏右下，旋转后移动到横屏右下)
136 | *
137 | * @param rotateType 旋转类型
138 | */
139 | private void onPhoneConfigChanged(ETypeRotateChange rotateType) {
140 | checkScreenSize();
141 | if (FwContent.isDebug) {
142 | L.i(rotateType + " [" + screenWidth + "*" + screenHeight + "]------> " + getX() + " * " + getY() + "------" + isBackToDesktop);
143 | }
144 | // // 应用内，不使用手机旋转(即传感器方向)
145 | // if (!isBackToDesktop && rotateType == ETypeRotateChange.T_SENSOR_ROTATE) {
146 | // return;
147 | // }
148 | //超出屏幕 移动到屏幕中间，确保超出屏幕的case能兼容处理
149 | if (Math.abs(getX() - screenWidth) > screenWidth / 3 || Math.abs(getY() - screenHeight) > screenWidth / 3
150 | || screenHeight == getY()
151 | ) {
152 | if (FwContent.isDebug) {
153 | L.w("超出屏幕...即将自动校正....");
154 | }
155 | updateX(screenWidth - 200);
156 | updateY(screenHeight * 2 / 3);
157 | } else {
158 | if (FwContent.isDebug) {
159 | L.d("未超出屏幕....");
160 | }
161 | }
162 |
163 |
164 | }
165 |
166 | @Override
167 | public void show() {
168 | if (once) {
169 | mFloatView.init();
170 | once = false;
171 | isShow = true;
172 | } else {
173 | if (isShow) {
174 | return;
175 | }
176 | getView().setVisibility(View.VISIBLE);
177 | isShow = true;
178 | }
179 | if (mBuilder.mViewStateListener != null) {
180 | mBuilder.mViewStateListener.onShow();
181 | }
182 | }
183 |
184 | @Override
185 | public void hide() {
186 | if (once || !isShow) {
187 | return;
188 | }
189 | getView().setVisibility(View.INVISIBLE);
190 | isShow = false;
191 | if (mBuilder.mViewStateListener != null) {
192 | mBuilder.mViewStateListener.onHide();
193 | }
194 | }
195 |
196 | @Override
197 | public boolean isShowing() {
198 | return isShow;
199 | }
200 |
201 | @Override
202 | public void dismiss() {
203 | mFloatView.dismiss();
204 | isShow = false;
205 | if (mBuilder.mViewStateListener != null) {
206 | mBuilder.mViewStateListener.onDismiss();
207 | }
208 | }
209 |
210 | @Override
211 | public void destory() {
212 | if (mFloatLifecycle != null) {
213 | mFloatLifecycle.unRegisterReceiver(mBuilder.mApplicationContext);
214 |
215 | }
216 | if (mAnimator != null && mAnimator.isRunning()) {
217 | mAnimator.cancel();
218 | }
219 | }
220 |
221 | @Override
222 | public void updateX(int x) {
223 | checkMoveType();
224 | mBuilder.xOffset = x;
225 | mFloatView.updateX(x);
226 | }
227 |
228 | @Override
229 | public void updateY(int y) {
230 | checkMoveType();
231 | mBuilder.yOffset = y;
232 | mFloatView.updateY(y);
233 | }
234 |
235 | @Override
236 | public void updateX(EScreen screenType, float ratio) {
237 | checkMoveType();
238 |
239 | // mBuilder.xOffset = (int)((screenType == EScreen.WIDTH ? ViewUtils.getScreenWidth(mBuilder.mApplicationContext)
240 | // : ViewUtils.getScreenHeight(mBuilder.mApplicationContext)) * ratio);
241 | mBuilder.xOffset = (int) ((screenType == EScreen.WIDTH ? screenWidth : screenHeight) * ratio);
242 | mFloatView.updateX(mBuilder.xOffset);
243 |
244 | }
245 |
246 | @Override
247 | public void updateY(EScreen screenType, float ratio) {
248 | checkMoveType();
249 | // mBuilder.yOffset = (int)((screenType == EScreen.WIDTH ? ViewUtils.getScreenWidth(mBuilder.mApplicationContext)
250 | // : ViewUtils.getScreenHeight(mBuilder.mApplicationContext)) * ratio);
251 | mBuilder.yOffset = (int) ((screenType == EScreen.WIDTH ? screenWidth : screenHeight) * ratio);
252 | mFloatView.updateY(mBuilder.yOffset);
253 |
254 | }
255 |
256 | @Override
257 | public int getX() {
258 | return mFloatView.getX();
259 | }
260 |
261 | @Override
262 | public int getY() {
263 | return mFloatView.getY();
264 | }
265 |
266 | @Override
267 | public View getView() {
268 | mSlop = ViewConfiguration.get(mBuilder.mApplicationContext).getScaledTouchSlop();
269 | return mBuilder.mView;
270 | }
271 |
272 | private void checkMoveType() {
273 | if (mBuilder.mMoveType == EMoveType.FIXED) {
274 | throw new IllegalArgumentException("FloatWindow of this tag is not allowed to move!");
275 | }
276 | }
277 |
278 | private void initTouchEvent() {
279 | checkScreenSize();
280 | if (mBuilder.mMoveType != EMoveType.INACTIVE) {
281 | getView().setOnTouchListener(new View.OnTouchListener() {
282 | float lastX, lastY, changeX, changeY;
283 | int newX, newY;
284 |
285 | @SuppressLint("ClickableViewAccessibility")
286 | @Override
287 | public boolean onTouch(View v, MotionEvent event) {
288 |
289 | try {
290 | switch (event.getAction()) {
291 | case MotionEvent.ACTION_DOWN:
292 | onActionDown(event);
293 | break;
294 | case MotionEvent.ACTION_MOVE:
295 | onActionMove(event);
296 | break;
297 | case MotionEvent.ACTION_UP:
298 | onActionUp(event, v);
299 | break;
300 | default:
301 | break;
302 | }
303 | } catch (Throwable e) {
304 | L.e(e);
305 | }
306 | return mClick;
307 | }
308 |
309 | private void onActionDown(MotionEvent event) {
310 | mClick = false;
311 | downX = event.getRawX();
312 | downY = event.getRawY();
313 | lastX = event.getRawX();
314 | lastY = event.getRawY();
315 | cancelAnimator();
316 | }
317 |
318 | private void onActionMove(MotionEvent event) {
319 | // if (!isOutOfRange(event.getRawX(), event.getRawY())) {
320 | changeX = event.getRawX() - lastX;
321 | changeY = event.getRawY() - lastY;
322 | newX = (int) (mFloatView.getX() + changeX);
323 | newY = (int) (mFloatView.getY() + changeY);
324 | mFloatView.updateXY(newX, newY);
325 | if (mBuilder.mViewStateListener != null) {
326 | mBuilder.mViewStateListener.onPositionUpdate(newX, newY);
327 | }
328 | lastX = event.getRawX();
329 | lastY = event.getRawY();
330 | // }
331 | }
332 |
333 | private void onActionUp(MotionEvent event, View v) {
334 | upX = event.getRawX();
335 | upY = event.getRawY();
336 | mClick = (Math.abs(upX - downX) > mSlop) || (Math.abs(upY - downY) > mSlop);
337 | // L.i("Raw [%f x %f] -- FloatView[%d x %d] 分辨率(%d---%d) ", upX, upY, mFloatView.getX(),
338 | // mFloatView.getY(), screenWidth, screenHeight);
339 | if (mBuilder.mMoveType == EMoveType.SLIDE) {
340 | int startX = mFloatView.getX();
341 | int startY = mFloatView.getY();
342 | // 如果图标滑动的坐标是在哪部分，根据坐标和边缘距离计算，相应的坐标
343 | int endX = (startX * 2 + v.getWidth() > screenWidth)
344 | ? screenWidth - v.getWidth() - mBuilder.mSlideRightMargin : mBuilder.mSlideLeftMargin;
345 | // 是否需要校正Y坐标
346 | if (isNeedMoveY(startY, upY)) {
347 | int endY = getY(startY, upY, v.getHeight());
348 | PropertyValuesHolder pvhX = PropertyValuesHolder.ofInt("x", mFloatView.getX(), endX);
349 | PropertyValuesHolder pvhY = PropertyValuesHolder.ofInt("y", mFloatView.getY(), endY);
350 | mAnimator = ObjectAnimator.ofPropertyValuesHolder(pvhX, pvhY);
351 | mAnimator.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
352 | @Override
353 | public void onAnimationUpdate(ValueAnimator animation) {
354 | int x = (Integer) animation.getAnimatedValue("x");
355 | int y = (Integer) animation.getAnimatedValue("y");
356 | mFloatView.updateXY(x, y);
357 | if (mBuilder.mViewStateListener != null) {
358 | mBuilder.mViewStateListener.onPositionUpdate(x, y);
359 | }
360 | }
361 | });
362 | } else {
363 | mAnimator = ObjectAnimator.ofInt(startX, endX);
364 | mAnimator.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
365 | @Override
366 | public void onAnimationUpdate(ValueAnimator animation) {
367 | int x = (Integer) animation.getAnimatedValue();
368 | mFloatView.updateX(x);
369 | if (mBuilder.mViewStateListener != null) {
370 | mBuilder.mViewStateListener.onPositionUpdate(x, (int) upY);
371 | }
372 | }
373 | });
374 | }
375 | startAnimator();
376 | } else if (mBuilder.mMoveType == EMoveType.BACK) {
377 | PropertyValuesHolder pvhX =
378 | PropertyValuesHolder.ofInt("x", mFloatView.getX(), mBuilder.xOffset);
379 | PropertyValuesHolder pvhY =
380 | PropertyValuesHolder.ofInt("y", mFloatView.getY(), mBuilder.yOffset);
381 | mAnimator = ObjectAnimator.ofPropertyValuesHolder(pvhX, pvhY);
382 | mAnimator.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
383 | @Override
384 | public void onAnimationUpdate(ValueAnimator animation) {
385 | int x = (Integer) animation.getAnimatedValue("x");
386 | int y = (Integer) animation.getAnimatedValue("y");
387 | mFloatView.updateXY(x, y);
388 | if (mBuilder.mViewStateListener != null) {
389 | mBuilder.mViewStateListener.onPositionUpdate(x, y);
390 | }
391 | }
392 | });
393 | startAnimator();
394 | }
395 | lastX = event.getRawX();
396 | lastY = event.getRawY();
397 | }
398 |
399 | /**
400 | * 是否需要移动Y坐标
401 | *
402 | * @param startY 悬浮窗获取的位置
403 | * @param upY 真实针对屏幕的位置
404 | * @return
405 | */
406 | private boolean isNeedMoveY(int startY, float upY) {
407 | if (startY < 0 || upY > screenHeight) {
408 | return true;
409 | }
410 | return false;
411 | }
412 |
413 | /**
414 | * 获取Y的坐标
415 | *
416 | * @param startY 悬浮窗获取的位置
417 | * @param upY 真实针对屏幕的位置
418 | * @param height 组建高度
419 | * @return
420 | */
421 | private int getY(int startY, float upY, int height) {
422 | // 挨近顶部处理
423 | if (startY < 0) {
424 | // return (int)(upY + (0 - startY));
425 | // return height;
426 | return (int) Math.abs(startY - upY);
427 | }
428 | // 接近底部处理
429 | if (upY > screenHeight) {
430 | return (int) (screenHeight - height - (Math.abs(screenHeight - upY)));
431 | }
432 | return 0;
433 | }
434 | });
435 | }
436 | }
437 |
438 | /**
439 | * 初始化屏幕分辨率
440 | */
441 | private void checkScreenSize() {
442 | // if (screenWidth == 0) {
443 | screenWidth = ViewUtils.getScreenWidth(mBuilder.mApplicationContext);
444 | // }
445 | // if (screenHeight == 0) {
446 | screenHeight = ViewUtils.getScreenHeight(mBuilder.mApplicationContext);
447 | // }
448 | }
449 |
450 | private void cancelAnimator() {
451 | if (mAnimator != null && mAnimator.isRunning()) {
452 | mAnimator.cancel();
453 | }
454 | }
455 |
456 | // /**
457 | // * 判断是否超出范围，根据自己需求设置比例大小，我自己设置的是0.025和0.975
458 | // * 这是合并一个哥们 没有完善。暂时不使用
459 | // * https://github.com/yhaolpz/FloatWindow/pull/89/commits/f48b0ea10351246da43bf7e259855a91e1314dbc
460 | // *
461 | // * @param x event.getRawX()
462 | // * @param y event.getRawY()
463 | // * @return
464 | // */
465 | // private boolean isOutOfRange(float x, float y) {
466 | // boolean b = true;
467 | // // float screenWidth = ViewUtils.getScreenWidth(mBuilder.mApplicationContext);
468 | // // float screenHeight = ViewUtils.getScreenHeight(mBuilder.mApplicationContext);
469 | // float widthRate, heightRate;
470 | // widthRate = (screenWidth - x) / screenWidth;
471 | // heightRate = (screenHeight - y) / screenHeight;
472 | // if (widthRate > 0.025 && widthRate < 0.975 && heightRate > 0.025 && heightRate < 0.975) {
473 | // b = false;
474 | // } else {
475 | // b = true;
476 | // }
477 | // return b;
478 | // }
479 |
480 | private void startAnimator() {
481 | if (mBuilder.mInterpolator == null) {
482 | if (mDecelerateInterpolator == null) {
483 | mDecelerateInterpolator = new DecelerateInterpolator();
484 | }
485 | mBuilder.mInterpolator = mDecelerateInterpolator;
486 | }
487 | mAnimator.setInterpolator(mBuilder.mInterpolator);
488 | mAnimator.addListener(new AnimatorListenerAdapter() {
489 | @Override
490 | public void onAnimationEnd(Animator animation) {
491 | mAnimator.removeAllUpdateListeners();
492 | mAnimator.removeAllListeners();
493 | mAnimator = null;
494 | if (mBuilder.mViewStateListener != null) {
495 | mBuilder.mViewStateListener.onMoveAnimEnd();
496 | }
497 | }
498 | });
499 | mAnimator.setDuration(mBuilder.mDuration).start();
500 | if (mBuilder.mViewStateListener != null) {
501 | mBuilder.mViewStateListener.onMoveAnimStart();
502 | }
503 | }
504 |
505 | }
506 |
--------------------------------------------------------------------------------
/floatwindow/src/com/yhao/floatwindow/utils/L.java:
--------------------------------------------------------------------------------
1 | package com.yhao.floatwindow.utils;
2 |
3 | import android.annotation.TargetApi;
4 | import android.app.Activity;
5 | import android.content.Intent;
6 | import android.os.BaseBundle;
7 | import android.os.Build;
8 | import android.os.Bundle;
9 | import android.os.Message;
10 | import android.text.TextUtils;
11 | import android.util.Log;
12 | import android.util.SparseArray;
13 |
14 | import org.json.JSONArray;
15 | import org.json.JSONException;
16 | import org.json.JSONObject;
17 |
18 | import java.io.PrintWriter;
19 | import java.io.StringReader;
20 | import java.io.StringWriter;
21 | import java.lang.ref.Reference;
22 | import java.lang.reflect.Field;
23 | import java.lang.reflect.Modifier;
24 | import java.util.ArrayList;
25 | import java.util.Arrays;
26 | import java.util.Collection;
27 | import java.util.Iterator;
28 | import java.util.List;
29 | import java.util.Locale;
30 | import java.util.Map;
31 | import java.util.Set;
32 | import java.util.regex.Matcher;
33 | import java.util.regex.Pattern;
34 |
35 | import javax.xml.transform.OutputKeys;
36 | import javax.xml.transform.Source;
37 | import javax.xml.transform.Transformer;
38 | import javax.xml.transform.TransformerFactory;
39 | import javax.xml.transform.stream.StreamResult;
40 | import javax.xml.transform.stream.StreamSource;
41 |
42 | /**
43 | * @Copyright © 2015 sanbo Inc. All rights reserved.
44 | * @Description
45 | * Log统一管理类,提供功能：
46 | * 1.log工具类支持全部打印 「支持Log的所有功能.」
47 | * 2.支持类似C的格式化输出或Java的String.format「%个数和参数个数需要一直才能格式化」
48 | * 3.支持Java堆栈打印
49 | * 4.支持键入和不键入TAG 「不键入tag,tag是sanbo，默认第一个参数String为tag」
50 | * 5.支持shell控制log是否打印.
51 | * tag为sanbo的控制命令：setprop log.tag.sanbo log等级.
52 | * log等级：VERBOSE/DEBUG/INFO/WARN/ERROR/ASSERT
53 | * 6.格式化输出.
54 | * 7.支持XML/JSON/Map/Array等更多对象打印
55 | *
56 | * @Version: 6.1
57 | * @Create: 2015年6月18日 下午4:14:01
58 | * @Author: sanbo
59 | */
60 | public class L {
61 |
62 | // 解析属性最大层级
63 | public static final int MAX_CHILD_LEVEL = 3;
64 | // 换行符
65 | public static final String BR = System.getProperty("line.separator");
66 | private static final int JSON_INDENT = 2;
67 | // 是否打印bug.建议在application中调用init接口初始化
68 | public static boolean USER_DEBUG = true;
69 | // 是否接受shell控制打印
70 | private static boolean isShellControl = true;
71 | // 是否打印详细log,详细打印调用的堆栈
72 | private static boolean isNeedCallstackInfo = false;
73 | // 是否按照条形框输出,有包裹域的输出
74 | private static boolean isNeedWrapper = false;
75 | // 是否格式化展示,主要针对JSON
76 | private static boolean isFormat = false;
77 | // 默认tag
78 | private static String DEFAULT_TAG = "FloatWindow";
79 | // 临时tag.用法：调用log中大于1个参数,且第一个参数为字符串,且不是format用法,字符串长度没超过协议值,此时启用临时tag
80 | private static String TEMP_TAG = "";
81 | // 规定每段显示的长度.每行最大日志长度 (Android Studio3.1最多2902字符)
82 | private static int LOG_MAXLENGTH = 2900;
83 | // 类名(getClassName).方法名(getMethodName)[行号(getLineNumber)]
84 | private static String content_simple_callstack = "简易调用堆栈: %s.%s[%d]";
85 | // 格式化时，行首封闭符
86 | private static String CONTENT_LINE = "║ ";
87 | // 空格
88 | private static String CONTENT_SPACE = " ";
89 | private static String CONTENT_LOG_INFO = "log info:";
90 | private static String CONTENT_LOG_EMPTY = "打印的日志信息为空!";
91 | private static String content_title_begin =
92 | "╔═══════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════";
93 | private static String content_title_info_callstack =
94 | "╔══════════════════════════════════════════════════════════════调用详情══════════════════════════════════════════════════════════════";
95 | private static String content_title_info_log =
96 | "╔══════════════════════════════════════════════════════════════日志详情══════════════════════════════════════════════════════════════";
97 | private static String content_title_info_error =
98 | "╔══════════════════════════════════════════════════════════════异常详情══════════════════════════════════════════════════════════════";
99 | private static String content_title_info_type = "╔════════════════════════════════════════════════════「%s"
100 | + "」════════════════════════════════════════════════════";
101 | private static String content_title_end =
102 | "╚═══════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════";
103 | /**
104 | * 行首为该符号时，不增加行首封闭符
105 | */
106 | private static String CONTENT_A = CONTENT_LINE;
107 | private static String CONTENT_B = "╔";
108 | private static String CONTENT_C = "╚";
109 | private static String CONTENT_D = " ╔";
110 | private static String CONTENT_E = " ╚";
111 | private static String CONTENT_WARNNING_SHELL =
112 | "Wranning....不够打印级别,请在命令行设置指令后重新尝试打印,命令行指令: adb shell setprop log.tag." + DEFAULT_TAG + " ";
113 | private static Character FORMATER = '%';
114 | private static List names = Arrays.asList(new String[]{"$change", "this$0"});
115 |
116 | private L() {
117 | }
118 |
119 | /*********************************************************************************************************/
120 | /**
121 | * 支持可变参数打印,根据不同的结构支持. 可以统一成一个接口
122 | */
123 |
124 | /**
125 | * 初始化接口
126 | *
127 | * @param showLog 是否展示log，默认展示
128 | * @param shellControl 是否使用shell控制log动态打印.默认不使用. shell设置方式：setprop log.tag.sanbo INFO
129 | * 最后一个参数为log等级,可选项目：VERBOSE/DEBUG/INFO/WARN/ERROR/ASSERT
130 | * @param needWarpper 是否需要格式化输出
131 | * @param needCallStackInfo 是否需要打印详细的堆栈调用信息.
132 | * @param format 是否需要格式化.
133 | * @param defaultTag android logcat的tag一个意义,不设置默认的tag为"sanbo"
134 | */
135 | public static void init(boolean showLog, boolean shellControl, boolean needWarpper, boolean needCallStackInfo,
136 | boolean format, String defaultTag) {
137 | USER_DEBUG = showLog;
138 | isShellControl = shellControl;
139 | isNeedWrapper = needWarpper;
140 | isNeedCallstackInfo = needCallStackInfo;
141 | isFormat = format;
142 | if (!TextUtils.isEmpty(defaultTag)) {
143 | DEFAULT_TAG = defaultTag;
144 | }
145 | }
146 |
147 | /*********************************************************************************************************/
148 | public static void v(Object... args) {
149 | if (isShellControl) {
150 | if (!Log.isLoggable(DEFAULT_TAG, Log.VERBOSE)) {
151 | Log.v(DEFAULT_TAG, CONTENT_WARNNING_SHELL + "VERBOSE");
152 | return;
153 | }
154 | }
155 | parserArgsMain(MLEVEL.VERBOSE, args);
156 | }
157 |
158 | public static void d(Object... args) {
159 | if (isShellControl) {
160 | if (!Log.isLoggable(DEFAULT_TAG, Log.DEBUG)) {
161 | Log.d(DEFAULT_TAG, CONTENT_WARNNING_SHELL + "DEBUG");
162 | return;
163 | }
164 | }
165 | parserArgsMain(MLEVEL.DEBUG, args);
166 | }
167 |
168 | public static void i(Object... args) {
169 | if (isShellControl) {
170 | if (!Log.isLoggable(DEFAULT_TAG, Log.INFO)) {
171 | Log.i(DEFAULT_TAG, CONTENT_WARNNING_SHELL + "INFO");
172 | return;
173 | }
174 | }
175 | parserArgsMain(MLEVEL.INFO, args);
176 | }
177 |
178 | public static void w(Object... args) {
179 | if (isShellControl) {
180 | if (!Log.isLoggable(DEFAULT_TAG, Log.WARN)) {
181 | Log.w(DEFAULT_TAG, CONTENT_WARNNING_SHELL + "WARN");
182 | return;
183 | }
184 | }
185 | parserArgsMain(MLEVEL.WARN, args);
186 | }
187 |
188 | public static void e(Object... args) {
189 | if (isShellControl) {
190 | if (!Log.isLoggable(DEFAULT_TAG, Log.ERROR)) {
191 | Log.e(DEFAULT_TAG, CONTENT_WARNNING_SHELL + "ERROR");
192 | return;
193 | }
194 | }
195 | parserArgsMain(MLEVEL.ERROR, args);
196 | }
197 |
198 | public static void wtf(Object... args) {
199 | if (isShellControl) {
200 | if (!Log.isLoggable(DEFAULT_TAG, Log.ASSERT)) {
201 | Log.wtf(DEFAULT_TAG, CONTENT_WARNNING_SHELL + "ASSERT");
202 | return;
203 | }
204 | }
205 | parserArgsMain(MLEVEL.WTF, args);
206 | }
207 |
208 | /**
209 | * 解析参数入口.这步骤开始忽略类型.解析所有参数,参数检查逻辑： 1.是否为String,若为String,则先判断是否格式化输出,不是再进行字符串转换格式尝试 2.对象其他类型判断:
210 | * StringBuffer>StringBuild>Throwable>Intent>List>Map
211 | *
212 | * @param level
213 | * @param args
214 | */
215 | private static void parserArgsMain(int level, Object[] args) {
216 |
217 | /*
218 | * 确认打印
219 | */
220 | if (!USER_DEBUG) {
221 | Log.e(DEFAULT_TAG, "请确认Log工具类已经设置打印!");
222 | return;
223 | }
224 |
225 | StringBuilder sb = new StringBuilder();
226 | // 开始
227 |
228 | if (isFormat) {
229 | sb.append(CONTENT_LOG_INFO).append("\n");
230 | }
231 | String stackinfo = getCallStaceInfo();
232 | if (!TextUtils.isEmpty(stackinfo)) {
233 | sb.append(stackinfo).append("\n");
234 | }
235 |
236 | if (args[0] instanceof String) {
237 | // if (isNeedWrapper) {
238 | // sb.append(content_title_info_log).append("\n");
239 | // }
240 | String one = (String) args[0];
241 | // 解析fromat
242 | if (one.contains(String.valueOf(FORMATER)) && args.length > 1) {
243 |
244 | /*
245 | * 参数解析
246 | */
247 | Object[] temp = new Object[args.length - 1];
248 | for (int i = 1; i < args.length; i++) {
249 | temp[i - 1] = args[i];
250 | }
251 |
252 | // 查找%个数
253 | Pattern p = Pattern.compile("%", Pattern.CASE_INSENSITIVE);
254 | Matcher m = p.matcher(one);
255 | int count = 0;
256 | while (m.find()) {
257 | count++;
258 | }
259 |
260 | /**
261 | * %和后面参数一样，则格式化，否则不进行格式化
262 | */
263 | if (count == temp.length) {
264 | // 格式化操作
265 | String log = String.format(Locale.getDefault(), one, temp);
266 | if (isNeedWrapper) {
267 | sb.append(content_title_info_log).append("\n");
268 | }
269 | sb.append(wrapperString(log)).append("\n");
270 | } else {
271 | if (isNeedWrapper) {
272 | sb.append(content_title_info_log).append("\n");
273 | }
274 | StringBuilder tempSB = new StringBuilder();
275 | for (Object obj : args) {
276 | // 解析成字符串,添加
277 | String tempStr = objectToString(obj);
278 | // Log.i(DEFAULT_TAG, "tempStr:" + tempStr);
279 | if (!TextUtils.isEmpty(tempStr)) {
280 | // sb.append(nativeWrapperString(temp)).append("\n");
281 | tempSB.append(tempStr).append("\t");
282 | }
283 | }
284 | sb.append(wrapperString(tempSB.toString())).append("\n");
285 | }
286 | } else {
287 | // 不符合format规则数据
288 | if (args.length > 1) {
289 | // 大于一次参数，第一个参数是字符串，默认是tag
290 | String log = processTagCase(args);
291 | if (!TextUtils.isEmpty(log)) {
292 | sb.append(wrapperString(log)).append("\n");
293 | } else {
294 | // 需要支持打印""或者null
295 | sb.append(wrapperString("")).append("\n");
296 | }
297 | } else {
298 | if (isNeedWrapper) {
299 | sb.append(content_title_info_log).append("\n");
300 | }
301 | sb.append(wrapperString(one)).append("\n");
302 | }
303 | }
304 | } else {
305 |
306 | for (Object obj : args) {
307 | // 解析成字符串,添加
308 | String temp = processObjectCase(obj);
309 | // Log.i(DEFAULT_TAG, "temp:" + temp);
310 | if (!TextUtils.isEmpty(temp)) {
311 | // sb.append(nativeWrapperString(temp)).append("\n");
312 | sb.append(temp).append("\n");
313 | }
314 | }
315 | }
316 | // 结束,标记结束符
317 | if (isNeedWrapper) {
318 | sb.append(content_title_end);
319 | }
320 | // 打印字符
321 | preparePrint(level, sb.toString());
322 |
323 | }
324 |
325 | /*********************************************************************************************************/
326 | /**
327 | * 基础工具方法
328 | */
329 | /*********************************************************************************************************/
330 |
331 | /**
332 | * 处理对象
333 | *
334 | * @param obj
335 | * @return
336 | */
337 | private static String processObjectCase(Object obj) {
338 |
339 | StringBuilder sb = new StringBuilder();
340 | try {
341 | // 1.解析对象
342 | String result = objectToString(obj);
343 | if (!TextUtils.isEmpty(result)) {
344 | // 2.打印行头
345 | header(obj, sb);
346 | // 3.打印内容
347 | sb.append(wrapperString(result));// .append("\n");
348 | } else {
349 | // 需要支持""或null
350 | if (isNeedWrapper) {
351 | sb.append(content_title_info_log).append("\n");
352 | }
353 | sb.append(wrapperString(""));// .append("\n");
354 | }
355 | } catch (Throwable e) {
356 | e.printStackTrace();
357 | }
358 | return sb.toString();
359 | }
360 |
361 | /**
362 | *
363 | * 只有第一个参数为字符串且不是格式化的情况下才会进入该方法.
364 | * 该方法是负责处理tag或者message的情况. 主要要支持多重格式：
365 | * 1.L.x(TAG,Object);
366 | * 2.L.x(msg,Object);
367 | * 默认第一个参数为字符串且参数大于2个，第一个参数就为tag
368 | *
369 | *
370 | * @param args
371 | * @return
372 | */
373 | private static String processTagCase(Object[] args) {
374 | String one = (String) args[0];
375 | StringBuilder sb = new StringBuilder();
376 | TEMP_TAG = one;
377 | for (int i = 1; i < args.length; i++) {
378 | sb.append(processObjectCase(args[i])).append("\n");
379 | }
380 | return sb.toString();
381 | }
382 |
383 | /**
384 | * 打印行头
385 | *
386 | * @param obj
387 | * @param sb
388 | */
389 | private static void header(Object obj, StringBuilder sb) {
390 | if (isNeedWrapper) {
391 | if (obj instanceof String) {
392 | sb.append(content_title_info_log).append("\n");
393 | } else if (obj instanceof Throwable) {
394 | sb.append(content_title_info_error).append("\n");
395 | } else {
396 | sb.append(String.format(content_title_info_type, obj.getClass().getName())).append("\n");
397 | }
398 | }
399 | }
400 |
401 | /**
402 | * 处理堆栈信息
403 | *
404 | * @return
405 | */
406 | private static String getCallStaceInfo() {
407 | Exception callStack = new Exception("debug_info call stack.");
408 | StringBuilder sb = new StringBuilder();
409 | StackTraceElement stackElement[] = Thread.currentThread().getStackTrace();
410 | // 现在文件
411 | boolean currentFile = false;
412 | // 现在文件多重调用
413 | boolean isKeeping = false;
414 | for (StackTraceElement ste : stackElement) {
415 | if (currentFile && !isKeeping) {
416 | break;
417 | }
418 | if (ste.getClassName().equals(L.class.getName())) {
419 | if (!currentFile) {
420 | currentFile = true;
421 | }
422 | isKeeping = true;
423 | continue;
424 | } else {
425 | if (currentFile) {
426 |
427 | // 堆栈的错误第一行可以不要
428 | String cc = null;
429 | if (isNeedCallstackInfo) {
430 | cc = parseString(callStack);
431 | String[] tempArray = cc.split("\n");
432 | StringBuilder tempSB = new StringBuilder();
433 | for (int i = 1; i < tempArray.length; i++) {
434 | tempSB.append(CONTENT_SPACE).append(CONTENT_SPACE).append(CONTENT_SPACE)
435 | .append(tempArray[i]);
436 | if (i != tempArray.length - 1) {
437 | tempSB.append("\n");
438 | }
439 | }
440 | cc = tempSB.toString();
441 | }
442 |
443 | if (isNeedWrapper) {
444 | if (isNeedCallstackInfo) {
445 |
446 | sb.append("\n").append(content_title_info_callstack).append("\n").append(CONTENT_LINE)
447 | .append(CONTENT_SPACE).append("文件名: " + ste.getFileName()).append("\n")
448 | .append(CONTENT_LINE).append(CONTENT_SPACE).append("类名: " + ste.getClassName())
449 | .append("\n").append(CONTENT_LINE).append(CONTENT_SPACE)
450 | .append("方法名: " + ste.getMethodName()).append("\n").append(CONTENT_LINE)
451 | .append(CONTENT_SPACE).append("行号: " + ste.getLineNumber()).append("\n")
452 | .append(CONTENT_LINE).append(CONTENT_SPACE)
453 | .append("Native方法:" + (!ste.isNativeMethod() ? "不是" : "是")).append("\n")
454 | .append(CONTENT_LINE).append(CONTENT_SPACE).append("调用堆栈详情:").append("\n")
455 | .append(wrapperString(cc));
456 | } else {
457 | sb.append("\n").append(content_title_begin).append("\n").append(CONTENT_LINE)
458 | .append(String.format(content_simple_callstack, ste.getClassName(), ste.getMethodName(),
459 | ste.getLineNumber()));
460 | // 上一层会处理
461 | // .append("\n");
462 | }
463 | } else {
464 | if (isNeedCallstackInfo) {
465 | sb.append("文件名: " + ste.getFileName()).append("\n")
466 | .append("类名: " + ste.getClassName()).append("\n")
467 | .append("方法名: " + ste.getMethodName()).append("\n")
468 | .append("行号: " + ste.getLineNumber()).append("\n")
469 | .append("Native方法:" + (!ste.isNativeMethod() ? "不是" : "是")).append("\n")
470 | .append("调用堆栈详情:").append("\n").append(wrapperString(cc));
471 | } else {
472 | if (isFormat) {
473 | sb.append(String.format(content_simple_callstack, ste.getClassName(),
474 | ste.getMethodName(), ste.getLineNumber()));
475 | }
476 | }
477 | }
478 |
479 | isKeeping = false;
480 | break;
481 | }
482 | }
483 | }
484 | currentFile = false;
485 | isKeeping = false;
486 | callStack = null;
487 | stackElement = null;
488 | return sb.toString();
489 | }
490 |
491 | /*********************************************************************************************************/
492 | /**
493 | * 解析对象成字符串
494 | */
495 |
496 | /*********************************************************************************************************/
497 | private static String objectToString(Object object) {
498 | return objectToString(object, 0);
499 | }
500 |
501 | /**
502 | * 是否为静态内部类
503 | *
504 | * @param cla
505 | * @return
506 | */
507 | private static boolean isStaticInnerClass(Class cla) {
508 | if (cla != null && cla.isMemberClass()) {
509 | int modifiers = cla.getModifiers();
510 | return (modifiers & Modifier.STATIC) == Modifier.STATIC;
511 | }
512 | return false;
513 | }
514 |
515 | /**
516 | * 根据类型匹配
517 | *
518 | * @param object
519 | * @param childLevel
520 | * @return
521 | */
522 | private static String objectToString(Object object, int childLevel) {
523 | if (object == null) {
524 | return null;
525 | }
526 | if (childLevel > MAX_CHILD_LEVEL) {
527 | return object.toString();
528 | }
529 | // 支持的类型.单独处理
530 | Class czz = object.getClass();
531 |
532 | if (Build.VERSION.SDK_INT > 20) {
533 | if (BaseBundle.class.isAssignableFrom(czz)) {
534 | BaseBundle bundle = (BaseBundle) object;
535 | return parseString(bundle);
536 | }
537 | } else {
538 | if (Bundle.class.isAssignableFrom(czz)) {
539 | Bundle bundle = (Bundle) object;
540 | return parseString(bundle);
541 | }
542 | }
543 | if (String.class.isAssignableFrom(czz)) {
544 | String obj = (String) object;
545 | return parseString(obj);
546 | } else if (Number.class.isAssignableFrom(czz)) {
547 | Number obj = (Number) object;
548 | return String.valueOf(obj);
549 | } else if (Intent.class.isAssignableFrom(czz)) {
550 | Intent obj = (Intent) object;
551 | return parseString(obj);
552 | } else if (Collection.class.isAssignableFrom(czz)) {
553 | Collection obj = (Collection) object;
554 | return parseString(obj);
555 | } else if (Map.class.isAssignableFrom(czz)) {
556 | Map obj = (Map) object;
557 | return parseString(obj);
558 | } else if (Throwable.class.isAssignableFrom(czz)) {
559 | Throwable obj = (Throwable) object;
560 | return parseString(obj);
561 | } else if (Reference.class.isAssignableFrom(czz)) {
562 | Reference obj = (Reference) object;
563 | return parseString(obj);
564 | } else if (Message.class.isAssignableFrom(czz)) {
565 | Message obj = (Message) object;
566 | return parseString(obj);
567 | // } else if (isSubClass(czz, Activity.class)) {
568 | } else if (Activity.class.isAssignableFrom(czz)) {
569 | Activity obj = (Activity) object;
570 | return parseString(obj);
571 | } else if (JSONArray.class.isAssignableFrom(czz)) {
572 | JSONArray obj = (JSONArray) object;
573 | return format(obj);
574 | } else if (JSONObject.class.isAssignableFrom(czz)) {
575 | JSONObject obj = (JSONObject) object;
576 | return format(obj);
577 | } else if (StringBuilder.class.isAssignableFrom(czz)) {
578 | StringBuilder obj = (StringBuilder) object;
579 | return obj.toString();
580 | } else if (StringBuffer.class.isAssignableFrom(czz)) {
581 | StringBuffer obj = (StringBuffer) object;
582 | return obj.toString();
583 | } else if (Class.class.isAssignableFrom(czz)) {
584 | return parseStringByObject(object, childLevel);
585 | } else if (isArray(object)) {
586 | StringBuilder result = new StringBuilder();
587 | traverseArray(result, object);
588 | return result.toString();
589 | } else {
590 | if (object.toString().startsWith(object.getClass().getName() + "@")) {
591 | return parseStringByObject(object, childLevel);
592 | } else {
593 | // 若对象重写toString()方法默认走toString()
594 | return object.toString();
595 | }
596 | }
597 | }
598 |
599 | /**
600 | * 拼接class的字段和值
601 | *
602 | * @param cla
603 | * @param obj
604 | * @param o 对象
605 | * @param childOffset 递归解析属性的层级
606 | */
607 | private static void getClassFields(Class cla, JSONObject obj, Object o, int childOffset) {
608 | try {
609 | if (cla.equals(Object.class)) {
610 | return;
611 | }
612 | // if (isSubClass) {
613 | // builder.append(BR + BR + "=> ");
614 | // }
615 | Field[] fields = cla.getDeclaredFields();
616 | for (int i = 0; i < fields.length; ++i) {
617 | Field field = fields[i];
618 | field.setAccessible(true);
619 | if (cla.isMemberClass() && !isStaticInnerClass(cla) && i == 0) {
620 | continue;
621 | }
622 |
623 | if ("$change".equals(field.getName())) {
624 | continue;
625 | }
626 | // 解决Instant Run情况下内部类死循环的问题
627 | // System.out.println(field.getName()+ "***" +subObject.getClass() + "啊啊啊啊啊啊" +
628 | // cla);
629 | if (!isStaticInnerClass(cla)
630 | && ("$change".equals(field.getName()) || "this$0".equalsIgnoreCase(field.getName()))) {
631 | continue;
632 | }
633 | Object subObject = null;
634 | try {
635 | subObject = field.get(o);
636 | } catch (IllegalAccessException e) {
637 | subObject = e;
638 | } finally {
639 | if (subObject != null) {
640 |
641 | if (childOffset < MAX_CHILD_LEVEL) {
642 | if (!Number.class.isAssignableFrom(subObject.getClass())) {
643 | subObject = objectToString(subObject, childOffset + 1);
644 | String s = (String) subObject;
645 | s = s.replaceAll("\n", "").replaceAll("\r", "").replaceAll("\r\n", "");
646 | try {
647 | JSONObject temp = new JSONObject(s);
648 | obj.put(field.getName(), temp);
649 | } catch (Throwable e) {
650 | try {
651 | JSONArray arr = new JSONArray(s);
652 | obj.put(field.getName(), arr);
653 | } catch (Throwable e2) {
654 | obj.put(field.getName(), s);
655 | }
656 | }
657 | } else {
658 | obj.put(field.getName(), subObject);
659 | }
660 | } else {
661 | obj.put(field.getName(), subObject.toString());
662 | }
663 | } else {
664 | obj.put(field.getName(), "null");
665 | }
666 | }
667 | }
668 | } catch (Throwable e) {
669 | e.printStackTrace();
670 | }
671 | }
672 |
673 | /**
674 | * 获取数组的纬度
675 | *
676 | * @param object
677 | * @return
678 | */
679 | private static int getArrayDimension(Object object) {
680 | int dim = 0;
681 | for (int i = 0; i < object.toString().length(); ++i) {
682 | if (object.toString().charAt(i) == '[') {
683 | ++dim;
684 | } else {
685 | break;
686 | }
687 | }
688 | return dim;
689 | }
690 |
691 | /**
692 | * 是否为数组
693 | *
694 | * @param object
695 | * @return
696 | */
697 | private static boolean isArray(Object object) {
698 | return object.getClass().isArray();
699 | }
700 |
701 | /**
702 | * 获取数组类型
703 | *
704 | * @param object 如L为int型
705 | * @return
706 | */
707 | private static char getType(Object object) {
708 | if (isArray(object)) {
709 | String str = object.toString();
710 | return str.substring(str.lastIndexOf("[") + 1, str.lastIndexOf("[") + 2).charAt(0);
711 | }
712 | return 0;
713 | }
714 |
715 | /**
716 | * 遍历数组
717 | *
718 | * @param result
719 | * @param array
720 | */
721 | private static void traverseArray(StringBuilder result, Object array) {
722 | if (isArray(array)) {
723 | if (getArrayDimension(array) == 1) {
724 | switch (getType(array)) {
725 | case 'I':
726 | result.append(Arrays.toString((int[]) array));
727 | break;
728 | case 'D':
729 | result.append(Arrays.toString((double[]) array));
730 | break;
731 | case 'Z':
732 | result.append(Arrays.toString((boolean[]) array));
733 | break;
734 | case 'B':
735 | result.append(Arrays.toString((byte[]) array));
736 | break;
737 | case 'S':
738 | result.append(Arrays.toString((short[]) array));
739 | break;
740 | case 'J':
741 | result.append(Arrays.toString((long[]) array));
742 | break;
743 | case 'F':
744 | result.append(Arrays.toString((float[]) array));
745 | break;
746 | case 'C':
747 | result.append(Arrays.toString((char[]) array));
748 | break;
749 | case 'L':
750 | Object[] objects = (Object[]) array;
751 | result.append("[");
752 | for (int i = 0; i < objects.length; ++i) {
753 | result.append(objectToString(objects[i]));
754 | if (i != objects.length - 1) {
755 | result.append(",");
756 | }
757 | }
758 | result.append("]");
759 | break;
760 | default:
761 | result.append(Arrays.toString((Object[]) array));
762 | break;
763 | }
764 | } else {
765 | result.append("[");
766 | for (int i = 0; i < ((Object[]) array).length; i++) {
767 | traverseArray(result, ((Object[]) array)[i]);
768 | if (i != ((Object[]) array).length - 1) {
769 | result.append(",");
770 | }
771 | }
772 | result.append("]");
773 | }
774 | } else {
775 | result.append("not a array!!");
776 | }
777 | }
778 |
779 | private static String parseStringByObject(Object object, int childLevel) {
780 | try {
781 | JSONObject obj = new JSONObject();
782 | getClassFields(object.getClass(), obj, object, childLevel);
783 | Class superClass = object.getClass().getSuperclass();
784 | if (superClass != null) {
785 | while (!superClass.equals(Object.class)) {
786 | getClassFields(superClass, obj, object, childLevel);
787 | superClass = superClass.getSuperclass();
788 | }
789 | } else {
790 | obj.put("toString", object.toString());
791 | }
792 | return format(obj);
793 | } catch (Throwable e) {
794 | return object.toString();
795 | }
796 | }
797 |
798 | private static String parseString(Activity activity) {
799 | JSONObject obj = new JSONObject();
800 | // Field[] fields = activity.getClass().getDeclaredFields();
801 | Field[] fields = activity.getClass().getFields();
802 | for (Field f : fields) {
803 | f.setAccessible(true);
804 | if ("org.aspectj.lang.JoinPoint$StaticPart".equals(f.getType().getName())) {
805 | continue;
806 | }
807 | if (names.contains(f.getName())) {
808 | continue;
809 | }
810 | try {
811 | Object fieldValue = f.get(activity);
812 | obj.put(f.getName(), objectToString(fieldValue));
813 | } catch (Throwable e) {
814 | e.printStackTrace();
815 | }
816 | }
817 |
818 | StringBuilder builder = new StringBuilder(activity.getClass().getName());
819 | builder.append(" {");
820 | builder.append(BR);
821 | for (Field field : fields) {
822 | field.setAccessible(true);
823 | if ("org.aspectj.lang.JoinPoint$StaticPart".equals(field.getType().getName())) {
824 | continue;
825 | }
826 | if (names.contains(field.getName())) {
827 | continue;
828 | }
829 | try {
830 | Object fieldValue = field.get(activity);
831 | builder.append(field.getName()).append("=>").append(objectToString(fieldValue)).append(BR);
832 | } catch (IllegalAccessException e) {
833 | e.printStackTrace();
834 | }
835 | }
836 | builder.append("}");
837 | Log.d("www", builder.toString());
838 | return format(obj);
839 | }
840 |
841 | private static String parseString(Message message) {
842 | if (message == null) {
843 | return null;
844 | }
845 | JSONObject obj = new JSONObject();
846 | try {
847 | obj.put("what", message.what);
848 | obj.put("when", message.getWhen());
849 | obj.put("arg1", message.arg1);
850 | obj.put("arg2", message.arg2);
851 | obj.put("data", parseString(message.getData()));
852 | obj.put("obj", objectToString(message.obj));
853 | } catch (Exception e) {
854 | e.printStackTrace();
855 | }
856 | return format(obj);
857 | }
858 |
859 | private static String parseString(Reference reference) {
860 | Object actual = reference.get();
861 | return objectToString(actual);
862 | }
863 |
864 | private static String parseString(Map map) {
865 | JSONObject obj = new JSONObject();
866 | Set keys = map.keySet();
867 | for (Object key : keys) {
868 | try {
869 | Object value = map.get(key);
870 | if (key == null) {
871 | key = "null";
872 | }
873 | if (value != null) {
874 | obj.put(objectToString(key), objectToString(value));
875 | } else {
876 | obj.put(objectToString(key), "null");
877 | }
878 | } catch (Throwable e) {
879 | e.printStackTrace();
880 | }
881 | }
882 | return format(obj);
883 |
884 | }
885 |
886 | private static String parseString(Collection collection) {
887 |
888 | JSONArray arr = new JSONArray();
889 | Iterator it = collection.iterator();
890 | while (it.hasNext()) {
891 | Object o = it.next();
892 | arr.put(objectToString(o));
893 | }
894 | return format(arr);
895 | }
896 |
897 | @TargetApi(21)
898 | private static String parseString(BaseBundle bundle) {
899 | if (bundle != null) {
900 | JSONObject bun = new JSONObject();
901 | for (String key : bundle.keySet()) {
902 | try {
903 | bun.put(key, objectToString(bundle.get(key)));
904 | } catch (Throwable e) {
905 | e.printStackTrace();
906 | }
907 | }
908 | return format(bun);
909 | }
910 | return null;
911 | }
912 |
913 | private static String parseString(Bundle bundle) {
914 | if (bundle != null) {
915 | JSONObject bun = new JSONObject();
916 | for (String key : bundle.keySet()) {
917 | try {
918 | bun.put(key, objectToString(bundle.get(key)));
919 | } catch (Throwable e) {
920 | e.printStackTrace();
921 | }
922 | }
923 | return format(bun);
924 | }
925 | return null;
926 | }
927 |
928 | /**
929 | * 处理对象且返回.处理顺序是： JSONObject>JSONArray>XML
930 | *
931 | * @param src
932 | * @return
933 | */
934 | private static String parseString(String src) {
935 | try {
936 | JSONObject oo = new JSONObject(src);
937 | return format(oo);
938 | } catch (JSONException e1) {
939 | // 不是JSONObject
940 | try {
941 | JSONArray arr = new JSONArray(src);
942 | return format(arr);
943 | } catch (JSONException e2) {
944 | // 不是JSONArray
945 |
946 | StringReader reader = null;
947 | try {
948 | reader = new StringReader(src);
949 | Source xmlInput = new StreamSource(reader);
950 | StreamResult xmlOutput = new StreamResult(new StringWriter());
951 | Transformer transformer = TransformerFactory.newInstance().newTransformer();
952 | transformer.setOutputProperty(OutputKeys.INDENT, "yes");
953 | transformer.setOutputProperty("{http://xml.apache.org/xslt}indent-amount", "2");
954 | transformer.transform(xmlInput, xmlOutput);
955 | String xml = xmlOutput.getWriter().toString().replaceFirst(">", ">\n");
956 | return xml;
957 | } catch (Throwable e3) {
958 | // 不是XML
959 | return src;
960 | } finally {
961 | if (reader != null) {
962 | reader.close();
963 | }
964 | }
965 | }
966 | } catch (Throwable e) {
967 | return src;
968 | }
969 | }
970 |
971 | /**
972 | * 将异常信息打印出来。出来数据是带行前的双竖线(如果设置wrapper是true),不带头
973 | *
974 | * @param e
975 | * @return
976 | */
977 | private static String parseString(Throwable e) {
978 | // 可以使用系统的这个接口
979 | // return Log.getStackTraceString(e);
980 | // 自己实现堆栈,较之官方的增加了两个字符的缩进
981 | StringWriter sw = null;
982 | PrintWriter pw = null;
983 | StringBuilder sb = new StringBuilder();
984 | try {
985 | sw = new StringWriter();
986 | pw = new PrintWriter(sw);
987 | e.printStackTrace(pw);
988 | pw.flush();
989 | sw.flush();
990 | String result = sw.toString();
991 | String[] ss = result.split("\n");
992 | String s = null;
993 | for (int i = 0; i < ss.length; i++) {
994 | s = ss[i];
995 | // 一般首第一个字符不知道是什么东西
996 | if ("at".equalsIgnoreCase(s.substring(1, 3))) {
997 | // 部分堆栈怕其他行缩进失误
998 | // if (i > 0) {
999 | sb.append(CONTENT_SPACE).append(s);
1000 | } else {
1001 | sb.append(s);
1002 | }
1003 | if (i != ss.length - 1) {
1004 | sb.append("\n");
1005 | }
1006 | }
1007 | } catch (Throwable error) {
1008 | error.printStackTrace();
1009 | } finally {
1010 | if (sw != null) {
1011 | try {
1012 | sw.close();
1013 | } catch (Throwable e1) {
1014 | e1.printStackTrace();
1015 | }
1016 | }
1017 | if (pw != null) {
1018 | pw.close();
1019 | }
1020 | }
1021 | return sb.toString();
1022 | }
1023 |
1024 | private static String parseString(Intent intent) {
1025 | JSONObject obj = new JSONObject();
1026 | try {
1027 | if (!TextUtils.isEmpty(intent.getScheme())) {
1028 | obj.put("Scheme", intent.getScheme());
1029 | }
1030 | if (!TextUtils.isEmpty(intent.getAction())) {
1031 | obj.put("Action", intent.getAction());
1032 | }
1033 | if (!TextUtils.isEmpty(intent.getDataString())) {
1034 | obj.put("DataString", intent.getDataString());
1035 | }
1036 | if (!TextUtils.isEmpty(intent.getType())) {
1037 | obj.put("Type", intent.getType());
1038 | }
1039 | if (!TextUtils.isEmpty(intent.getPackage())) {
1040 | obj.put("Package", intent.getPackage());
1041 | }
1042 | if (!TextUtils.isEmpty(intent.getComponent().toString())) {
1043 | obj.put("ComponentInfo", intent.getComponent().toString());
1044 | }
1045 | if (!TextUtils.isEmpty(intent.getCategories().toString())) {
1046 | obj.put("Categories", intent.getCategories().toString());
1047 | }
1048 | String extras = parseString(intent.getExtras());
1049 | if (!TextUtils.isEmpty(extras)) {
1050 | obj.put("Extras", extras);
1051 | }
1052 | String flags = getFlags(intent.getFlags());
1053 | if (!TextUtils.isEmpty(flags)) {
1054 | obj.put("Flags", intent.getType());
1055 | }
1056 | } catch (JSONException e) {
1057 | e.printStackTrace();
1058 | }
1059 |
1060 | return format(obj);
1061 | }
1062 |
1063 | private static String getFlags(int flags) {
1064 | // 获取相应信息
1065 | SparseArray flagMap = new SparseArray();
1066 | Class cla = Intent.class;
1067 | Field[] fields = cla.getDeclaredFields();
1068 | for (Field field : fields) {
1069 | try {
1070 | field.setAccessible(true);
1071 | if (field.getName().startsWith("FLAG_")) {
1072 | int value = 0;
1073 | Object object = field.get(cla);
1074 | if (object instanceof Integer || "int".equals(object.getClass().getSimpleName())) {
1075 | value = (Integer) object;
1076 | }
1077 |
1078 | if (flagMap.get(value) == null) {
1079 | flagMap.put(value, field.getName());
1080 | }
1081 | }
1082 | } catch (Throwable e) {
1083 | }
1084 | }
1085 |
1086 | StringBuilder builder = new StringBuilder();
1087 | for (int i = 0; i < flagMap.size(); i++) {
1088 | int flagKey = flagMap.keyAt(i);
1089 | if ((flagKey & flags) == flagKey) {
1090 | builder.append(flagMap.get(flagKey));
1091 | builder.append(" | ");
1092 | }
1093 | }
1094 | if (TextUtils.isEmpty(builder.toString())) {
1095 | builder.append(flags);
1096 | } else if (builder.indexOf("|") != -1) {
1097 | builder.delete(builder.length() - 2, builder.length());
1098 | }
1099 | return builder.toString();
1100 | }
1101 |
1102 | /**
1103 | * 格式化输出JSONArray
1104 | *
1105 | * @param arr
1106 | * @return
1107 | */
1108 | private static String format(JSONArray arr) {
1109 | if (arr != null) {
1110 | try {
1111 | return isFormat ? (arr.toString(JSON_INDENT)) : arr.toString();
1112 | } catch (Exception e) {
1113 | e.printStackTrace();
1114 | }
1115 | }
1116 | return "";
1117 | }
1118 |
1119 | /*********************************************************************************************************/
1120 | /**
1121 | * 格式化字符串、异常、JSONArray、JSONObject
1122 | */
1123 | /*********************************************************************************************************/
1124 |
1125 | /**
1126 | * 格式化输出JSONObject
1127 | *
1128 | * @param obj
1129 | * @return
1130 | */
1131 | private static String format(JSONObject obj) {
1132 |
1133 | if (obj != null) {
1134 | try {
1135 | return isFormat ? obj.toString(JSON_INDENT) : obj.toString();
1136 | } catch (Exception e) {
1137 | e.printStackTrace();
1138 | }
1139 | }
1140 | return "";
1141 | }
1142 |
1143 | /**
1144 | * 字符串处理,wrapper选中情况下,行首加封闭符
1145 | *
1146 | * @param log
1147 | * @return
1148 | */
1149 | private static String wrapperString(String log) {
1150 | StringBuilder sb = new StringBuilder();
1151 |
1152 | if (TextUtils.isEmpty(log)) {
1153 | if (isNeedWrapper) {
1154 | sb.append(CONTENT_LINE);
1155 | }
1156 | sb.append(CONTENT_LOG_EMPTY);
1157 | return sb.toString();
1158 | }
1159 | String ss[] = new String[]{};
1160 | String temp = null;
1161 | if (log.contains("\n")) {
1162 | ss = log.split("\n");
1163 | if (ss.length > 0) {
1164 | sb = new StringBuilder();
1165 | for (int i = 0; i < ss.length; i++) {
1166 | temp = ss[i];
1167 | if (isNeedWrapper && !temp.startsWith(CONTENT_A) && !temp.startsWith(CONTENT_B)
1168 | && !temp.startsWith(CONTENT_C) && !temp.startsWith(CONTENT_D)
1169 | && !temp.startsWith(CONTENT_LOG_INFO) && !TextUtils.isEmpty(temp)
1170 | && !temp.startsWith(CONTENT_E)) {
1171 | sb.append(CONTENT_LINE);
1172 | }
1173 | sb.append(temp);
1174 |
1175 | if (i != ss.length - 1) {
1176 | sb.append("\n");
1177 | }
1178 | }
1179 | }
1180 | } else if (log.contains("\r")) {
1181 | ss = log.split("\r");
1182 | if (ss.length > 0) {
1183 | sb = new StringBuilder();
1184 | for (int i = 0; i < ss.length; i++) {
1185 | temp = ss[i];
1186 |
1187 | if (isNeedWrapper && !temp.startsWith(CONTENT_A) && !temp.startsWith(CONTENT_B)
1188 | && !temp.startsWith(CONTENT_D) && !temp.startsWith(CONTENT_E)
1189 | && !temp.startsWith(CONTENT_LOG_INFO) && !TextUtils.isEmpty(temp)
1190 | && !temp.startsWith(CONTENT_C)) {
1191 | sb.append(CONTENT_LINE);
1192 | }
1193 | sb.append(temp);
1194 | if (i != ss.length - 1) {
1195 | sb.append("\r");
1196 | }
1197 | }
1198 | }
1199 | } else if (log.contains("\r\n")) {
1200 | ss = log.split("\r\n");
1201 | if (ss.length > 0) {
1202 | sb = new StringBuilder();
1203 | for (int i = 0; i < ss.length; i++) {
1204 | temp = ss[i];
1205 |
1206 | if (isNeedWrapper && !temp.startsWith(CONTENT_A) && !temp.startsWith(CONTENT_B)
1207 | && !temp.startsWith(CONTENT_D) && !temp.startsWith(CONTENT_E)
1208 | && !temp.startsWith(CONTENT_LOG_INFO) && !TextUtils.isEmpty(temp)
1209 | && !temp.startsWith(CONTENT_C)) {
1210 | sb.append(CONTENT_LINE);
1211 | }
1212 | sb.append(temp);
1213 |
1214 | if (i != ss.length - 1) {
1215 | sb.append("\r\n");
1216 | }
1217 | }
1218 | }
1219 | } else if (log.contains("\n\r")) {
1220 | ss = log.split("\n\r");
1221 | if (ss.length > 0) {
1222 | sb = new StringBuilder();
1223 | for (int i = 0; i < ss.length; i++) {
1224 | temp = ss[i];
1225 | if (isNeedWrapper && !temp.startsWith(CONTENT_A) && !temp.startsWith(CONTENT_B)
1226 | && !temp.startsWith(CONTENT_D) && !temp.startsWith(CONTENT_E)
1227 | && !temp.startsWith(CONTENT_LOG_INFO) && !TextUtils.isEmpty(temp)
1228 | && !temp.startsWith(CONTENT_C)) {
1229 | sb.append(CONTENT_LINE);
1230 | }
1231 | sb.append(temp);
1232 |
1233 | if (i != ss.length - 1) {
1234 | sb.append("\n\r");
1235 | }
1236 | }
1237 | }
1238 | } else {
1239 | if (isNeedWrapper && !log.startsWith(CONTENT_A) && !log.startsWith(CONTENT_B) && !log.startsWith(CONTENT_D)
1240 | && !log.startsWith(CONTENT_LOG_INFO) && !TextUtils.isEmpty(log) && !log.startsWith(CONTENT_E)
1241 | && !log.startsWith(CONTENT_C)) {
1242 | sb.append(CONTENT_LINE);
1243 | }
1244 | sb.append(log);
1245 | }
1246 | return sb.toString();
1247 | }
1248 |
1249 | /*********************************************************************************************************/
1250 | /**
1251 | * 字符串包裹处理
1252 | */
1253 | /*********************************************************************************************************/
1254 |
1255 | /**
1256 | * 动态检查临时.切割大文件
1257 | *
1258 | * @param level
1259 | * @param msg
1260 | */
1261 | private static void preparePrint(int level, String msg) {
1262 | String tag = DEFAULT_TAG;
1263 | if (!TextUtils.isEmpty(TEMP_TAG)) {
1264 | tag = TEMP_TAG;
1265 | }
1266 |
1267 | if (msg.length() > LOG_MAXLENGTH) {
1268 | List splitStr = getStringBysplitLine(msg, LOG_MAXLENGTH);
1269 |
1270 | StringBuilder sb = null;
1271 | for (int i = 0; i < splitStr.size(); i++) {
1272 | String line = splitStr.get(i);
1273 |
1274 | if (sb == null) {
1275 | sb = new StringBuilder();
1276 | }
1277 | if (sb.length() + line.length() >= LOG_MAXLENGTH) {
1278 | realPrint(level, tag, wrapperString(sb.toString()));
1279 | sb = new StringBuilder();
1280 | if (line.length() >= LOG_MAXLENGTH) {
1281 | realPrint(level, tag, wrapperString(line));
1282 | } else {
1283 | sb.append(line);
1284 | }
1285 | if (i != splitStr.size() - 1) {
1286 | sb.append("\n");
1287 | }
1288 | } else {
1289 | sb.append(line);
1290 | if (i != splitStr.size() - 1) {
1291 | sb.append("\n");
1292 | }
1293 | }
1294 | }
1295 | if (sb != null) {
1296 | realPrint(level, tag, wrapperString(sb.toString()));
1297 | sb = null;
1298 | }
1299 | } else {
1300 | realPrint(level, tag, wrapperString(msg));
1301 | }
1302 | TEMP_TAG = "";
1303 | }
1304 |
1305 | /*********************************************************************************************************/
1306 | /**
1307 | * 打印方法
1308 | */
1309 | /*********************************************************************************************************/
1310 |
1311 | /**
1312 | * 真正打印单个信息
1313 | *
1314 | * @param level
1315 | * @param tag
1316 | * @param printStr
1317 | */
1318 | private static void realPrint(int level, String tag, String printStr) {
1319 | switch (level) {
1320 | case MLEVEL.DEBUG:
1321 | Log.d(tag, printStr);
1322 | break;
1323 | case MLEVEL.INFO:
1324 | Log.i(tag, printStr);
1325 | break;
1326 | case MLEVEL.ERROR:
1327 | Log.e(tag, printStr);
1328 | break;
1329 | case MLEVEL.VERBOSE:
1330 | Log.v(tag, printStr);
1331 | break;
1332 | case MLEVEL.WARN:
1333 | Log.w(tag, printStr);
1334 | break;
1335 | case MLEVEL.WTF:
1336 | Log.wtf(tag, printStr);
1337 | break;
1338 | default:
1339 | break;
1340 | }
1341 | }
1342 |
1343 | /**
1344 | * 按行分割字符串
1345 | *
1346 | * @param msg
1347 | * @param maxLen
1348 | * @return
1349 | */
1350 | private static List getStringBysplitLine(String msg, int maxLen) {
1351 | List result = new ArrayList();
1352 | String[] lines = msg.split("\n");
1353 | if (lines.length == 1) {
1354 | lines = msg.split("\r");
1355 | if (lines.length == 1) {
1356 | lines = msg.split("\r\n");
1357 | if (lines.length == 1) {
1358 | lines = msg.split("\n\r");
1359 | }
1360 | }
1361 | }
1362 | if (lines.length > 1) {
1363 |
1364 | for (int i = 0; i < lines.length; i++) {
1365 | String line = lines[i];
1366 | // 单行都超过最大长度，直接按照字符串分别来做
1367 | processLine(maxLen, result, line);
1368 | }
1369 | } else {
1370 | processLine(maxLen, result, msg);
1371 | }
1372 |
1373 | return result;
1374 | }
1375 |
1376 | /**
1377 | * 处理单行超长处理
1378 | *
1379 | * @param maxLen
1380 | * @param result
1381 | * @param line
1382 | */
1383 | private static void processLine(int maxLen, List result, String line) {
1384 | if (line.length() > maxLen) {
1385 | int current = 0;
1386 | String str;
1387 | while (true) {
1388 | try {
1389 | str = line.substring(current, current + maxLen);
1390 | result.add(str);
1391 | current += maxLen;
1392 | } catch (StringIndexOutOfBoundsException e) {
1393 | str = line.substring(current, line.length());
1394 | result.add(str);
1395 | break;
1396 | }
1397 | }
1398 | } else {
1399 | result.add(line);
1400 | }
1401 | }
1402 |
1403 | public static final class MLEVEL {
1404 | public static final int VERBOSE = 0x1;
1405 | public static final int DEBUG = 0x2;
1406 | public static final int INFO = 0x3;
1407 | public static final int WARN = 0x4;
1408 | public static final int ERROR = 0x5;
1409 | public static final int WTF = 0x6;
1410 | }
1411 |
1412 | }
--------------------------------------------------------------------------------