Android手机变身无线路由器_百度文库
您的浏览器Javascript被禁用，需开启后体验完整功能，
享专业文档下载特权
&赠共享文档下载特权
&10W篇文档免费专享
&每天抽奖多种福利
两大类热门资源免费畅读
续费一年阅读会员，立省24元！
Android手机变身无线路由器
&&1、解决户外应急办公、假日外出、出差旅游途中、农村山区有线宽带不到之处;2、解决第一代的iPad、iTouch不支持天翼3G信号的问题。现在只需在手机上装个无线路由设置软件(Wireless tether)就可以很方便地通过设置天翼3GAndroid手机无线路由,轻松实现PC、iPad、iTouch上网。户外应急办公收发邮件、处理文件或下载歌曲、浏览网页、高铁海底隧道等特殊环境下天翼3G超强信号让你随时随地享受高速上网。
阅读已结束，下载本文需要
想免费下载更多文档？
定制HR最喜欢的简历
下载文档到电脑，同时保存到云知识，更方便管理
加入VIP
还剩2页未读，
定制HR最喜欢的简历
你可能喜欢能否把安卓手机改造成路由器_百度知道
能否把安卓手机改造成路由器
我猜到有好多朋友要告诉我打开无线热点就可以让电脑用手机的流量。。。。其实我问的不是这个事情啦，大家不要想得太简单
我手里有一台闲置的安卓手机，1ghz处理器，512内存。还有一台低端路由器，大概8m内存吧，我的意思是能不能把手机的处理器和内存给路由器...
我有更好的答案求助知道网友
目前百度贴吧的“安智路由”貌似可以，是一个运行在ARM环境中的OPENWRT平台，前提是手机必须ROOT。
这个肯定是不能的，按你说的，你的闲置安卓手机和低端路由器不如卖掉，最少也能卖到200多元吧，然后换个好路由器不是更好吗
想法很好，但是不可行的，路由器的网络模块和手机的CPU支持的芯片是完全不一样的，必须对应才可以的。另外手机开启WIFI热点也不能完全替代路由器，因为手机本身的限制，WIFI网络模块的发射距离有限，而且吞吐量很小。
不能的 电脑可以 毒霸无线wifi只要有网 就可以让电脑化身为路由器 望采纳
想法是好的
cpu肯定换不了，内存的话，你可以拆开手机看看你的手机内存是什么型号？如果可以和路由器的互换，到是可以把内存换到路由器上。。。但是路由器也得看这次多大的内存，一般路由器扩大到32M就很大了，基本上用不到512M的内存。。。。再一个，就算是内存换上去了，你的路由器原来是什么模式还是什么模式，不可能原来是有线的，换个cpu、内存上去就变无线路由器，这是不可能的，无线路由器是要硬件来支持的，不是刷个固件就可以实现的。。。。。。比较理想的方法是看你的手机是否支持作为wifi热点的功能。。。有些安卓手机是可以装一个软件，让手机的无线变成wifi热点，从而共享手机的网络来上网。这个功能不是所有的手机都支持，只有一些手机支持而已
本回答被提问者采纳
其他3条回答
为您推荐：
其他类似问题
您可能关注的内容
安卓手机的相关知识
换一换
回答问题，赢新手礼包
个人、企业类
违法有害信息,请在下方选择后提交
色情、暴力
我们会通过消息、邮箱等方式尽快将举报结果通知您。Android 组件化 —— 路由设计最佳实践
这篇文章会告诉你
什么是路由，是为了解决什么问题才产生的业界现状是怎么样的，我们可以做什么来优化当前的问题路由设计思路是怎么样的，该怎么设计比较好如何用注解实现路由表URL的参数如何依赖注入到Activity、Fragement如何HookOnActivityResult，不需要再进行requstCode判断如何异步拦截路由，实现线程切换，不阻塞页面跳转如何用Apt实现Retrofit接口式调用如何找到Activity的调用方如何实现路由的安全调用如何避开Apt不能汇总所有Module路由的问题前言
当前Android的路由库实在太多了，刚开始的时候想为什么要用路由表的库，用Android原生的Scheme码不就好了，又不像iOS只能类依赖，后面越深入就越发现当时想的太简单了，后面看到Retrofit和OkHttp，才想到页面请求本质和网络请求不是一样吗，终于业界最简单高效的路由方案1.0出来了开源的库后面会放在公司github地址上面
什么是路由
根据路由表将页面请求分发到指定页面
App接收到一个通知，点击通知打开App的某个页面浏览器App中点击某个链接打开App的某个页面运营活动需求，动态把原生的页面替换成H5页面打开页面需要某些条件，先验证完条件，再去打开那个页面不合法的打开App的页面被屏蔽掉H5打开链接在所有平台都一样，方便统一跳转App存在就打开页面，不存在就去下载页面下载,只有Google的App Link支持为什么要有路由
Android原生已经支持AndroidManifest去管理App跳转，为什么要有路由库，这可能是大部分人接触到Android各种Router库不太明白的地方，这里我讲一下我的理解
显示Intent：项目庞大以后，类依赖耦合太大，不适合组件化拆分隐式Intent：协作困难，调用时候不知道调什么参数每个注册了Scheme的Activity都可以直接打开，有安全风险AndroidMainfest集中式管理比较臃肿无法动态修改路由，如果页面出错，无法动态降级无法动态拦截跳转，譬如未登录的情况下，打开登录页面，登录成功后接着打开刚才想打开的页面H5、Android、iOS地址不一样，不利于统一跳转怎么样的路由才算好路由
路由说到底还是为了解决开发者遇到的各种奇葩需求，使用简单、侵入性低、维护方便是首要条件，不影响你原来的代码，写入代码也很少，这里就要说说我的OkDeepLink的五大功能了，五大功能瞬间击中你的各种痛点，早点下班不是梦。
编译时注解，实现静态路由表,不再需要在臃肿的AndroidManifest中找到那个Actvity写Scheme和Intent Filter异步拦截器，实现动态路由，安全拦截、动态降级难不倒你模仿Retrofit接口式调用，实现方式用apt，不耗性能，参数调用不再是问题HookOnActivityResult,支持RxJava响应式调用,不再需要进行requestCode判断参数依赖注入，自动保存，不再需要手动写onSaveInstance、onCreate(SaveInstace)、onNewIntent(Intent)、getQueryParamer注册路由
路由结构图
大部分路由库都用Apt(编译时注解)生成路由表，然后用路由表转发到指定页面
OkDeepLink
注解式接口注册
每个module都要手动注册
每个module的路由表都要类查找
AndroidManiFest配置
每个module都要手动注册
系统Intent
Activity转发
Activity转发
Activity转发
Activity转发
Activity转发
Rxjava实现异步拦截器
Rxjava实现异步拦截器
Rxjava实现异步拦截器
Apt依赖注入，支持所有类型，不需要在Activity的onCreate中手动调用get方法
参数定义在path，不利于多人协作
Apt依赖注入，但是要手动调用get方法
Rxjava回调
onActivityResult
onActivityResult
onActivityResult
onActivityResult
Module接入不同App
其实说到底，路由的本质就是注册再转发，围绕着转发可以进行各种操作，拦截，替换，参数获取等等，其他Apt、Rxjava说到底都只是为了方便使用出现的，这里你会发现各种路由库反而为了修复各种工具带来的问题，出现了原来没有的问题，譬如为了解决Apt没法汇总所有Module路由，每个module都要手动注册，为了解决Apt没法汇总所有Module路由，通过类操作耗时，才出现分组的概念。
原理流程图
我这边是完全按照URL规范了，这里要说一下，现在好多方法是把参数定义在path里面的，虽然这样做，有不需要额外传参数的好处，但是这样路由就没有那么灵活，调试起来就没有那么方便了。
建议有好几款app的公司，host都一样，只有scheme不一样，这样只要替换Scheme就能实现降级，维护也简单。
AndroidManifest里面的acitivity声明scheme码是不安全的，所有App都可以打开这个页面，这里就产生有两种方式去注册，
注解产生路由表，通过DispatchActivity转发AndroidManifest注册，将其export=fasle，但是再通过DispatchActivity转发Intent，天猫就是这么做的，比上面的方法的好处是路由查找都是系统调用，省掉了维护路由表的过程，但是AndroidManifest配置还是比较不方便的我现在还是采用了注解，后面我会结合两种方法，将注解自动修改AndroidManifest，对于接入方是没有变动的，方法已经找到了，用自定义Lint扫描出注解相关的Activity，然后用processManifestTask修改Manifest，有个demo了，后面会接入。
生成路由表
譬如通过Apt把这段代码
public interface SampleService {
@Path("/main")
@Activity(MainActivity.class)
void startMainActivity(@Query("key") String key);
@After("execution(* okdeeplink.DeepLinkClient.init(..))")
public void init() {
DeepLinkClient.addAddress(new Address("/main", MainActivity.class));
初始化路由表
这里就要提一下使用Apt会造成每个module都要手动注册
是这么做的
@DeepLinkModule
public class SampleModule {
@DeepLinkHandler({ SampleModule.class, LibraryDeepLinkModule.class })
public class DeepLinkActivity extends Activity {
@Override protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
DeepLinkDelegate deepLinkDelegate = new DeepLinkDelegate(
new SampleModuleLoader(), new LibraryDeepLinkModuleLoader());
deepLinkDelegate.dispatchFrom(this);
是通过类查找,就比较耗时了，所以他又加入了分组的概念，按需加载
packageName 包名
所有class的集合
public static List&String& getFileNameByPackageName(Context context, String packageName) throws PackageManager.NameNotFoundException, IOException {
List&String& classNames = new ArrayList&&();
for (String path : getSourcePaths(context)) {
DexFile dexfile = null;
if (path.endsWith(EXTRACTED_SUFFIX)) {
dexfile = DexFile.loadDex(path, path + ".tmp", 0);
dexfile = new DexFile(path);
Enumeration&String& dexEntries = dexfile.entries();
while (dexEntries.hasMoreElements()) {
String className = dexEntries.nextElement();
if (className.contains(packageName)) {
classNames.add(className);
} catch (Throwable ignore) {
Log.e("ARouter", "Scan map file in dex files made error.", ignore);
} finally {
if (null != dexfile) {
dexfile.close();
} catch (Throwable ignore) {
Log.d("ARouter", "Filter " + classNames.size() + " classes by packageName &" + packageName + "&");
return classN
就比较巧妙了，通过Stub项目，其他地方都是provide的，只有主工程里面用Apt生成RouterInit类,虽然还是要写module的注解
if (hasModules) {
debug("generate modules RouterInit");
generateModulesRouterInit(moduleNames);
} else if (!hasModule) {
debug("generate default RouterInit");
generateDefaultRouterInit();
是最简单的，转发一下Intent就可以，但是这样就没法享受注解的好处了。
而我用aspectj解决了这个问题，会自动汇总所有module的路由省略了这些多余的代码，或者有谁知道用Apt自生怎么解决，请联系我一下。
@After("execution(* okdeeplink.DeepLinkClient.init(..))")
public void init() {
DeepLinkClient.addAddress(new Address("/main", MainActivity.class));
路由查找就是查找路由表对应的页面，值得提起的就是因为要适应Module接入不同App，Scheme要自动适应，路由表其实是Path---》Activity，这样的话内部跳转的时候Uri是没有的。而我这边是有的，我组装了一个内部的Uri，这样拦截器不会有影响。
public Request buildRequest(Intent sourceIntent) {
if (sourceIntent == null) {
return null;
Intent newIntent = new Intent(sourceIntent);
Uri uri = newIntent.getData();
addNewTaskFlag(newIntent);
if (uri != null) {
addBundleQuery(newIntent, uri);
Address entry = new DeepLinkClient(context).matchUrl(uri.toString());
if (entry == null || entry.getActivityClass() == null) {
return new Request(newIntent, this).setDeepLink(false);
newIntent.setComponent(new ComponentName(context, entry.getActivityClass()));
return new Request(newIntent, this);
return new Request(newIntent, this).setDeepLink(false);
现在所有路由方案分发都是用Activity做分发的，这样做会有这几个缺点
每次都要启动一个Activity，而Activity就算不写任何代码启动都要0.1秒如果是异步等待的话，Activiy要在合适时间finish，不然会有一层透明的页面阻挡操作对于第一个问题，有两个方法
QQ音乐是把DispatchActivity设为SingleInstacne,但是这样的话，动画会奇怪，堆栈也会乱掉，后退会有一层透明的页面阻挡操作DispatchActivity只在外部打开的时候调用我选择了第二种
对于第二个问题，有两个方法
DispatchActivity再把Intent转发到Service,再finish，这种方法唯一的缺陷是拦截器里面的context是Servcie的activity，就没发再拦截器里面弹出对话框了。DispatchActivity在打开和错误的时候finish,如果activity已经finish了，就用application的context去转发路由我选择了第二种
public void dispatchFrom(Intent intent) {
new DeepLinkClient(this)
.buildRequest(intent)
.dispatch()
.subscribe(new Subscriber&Request&() {
public void onCompleted() {
public void onError(Throwable e) {
public void onNext(Request request) {
Intent dispatchIntent = request.getIntent();
startActivity(dispatchIntent);
其实处理透明Activity阻挡操作可以采用取消所有事件变成无感页面的方法
我找到一种方式解决这个问题
这里我封装了一个库RxActivityResult去捕获onActivityResult，这样能保正流式调用
譬如拍照可以这样写,先定义一个接口
public interface ImageCaptureService {
@Action(MediaStore.ACTION_IMAGE_CAPTURE)
Observable&Response& startImageCapture();
然后这样调用
public class MainActivity extends AppCompatActivity {
ImageCaptureService imageCaptureS
public void captureImage(){
imageCaptureService
.startImageCapture()
.subscribe(new Action1&Response&() {
public void call(Response response) {
Intent data = response.getData();
int resultCode = response.getResultCode();
if (resultCode == RESULT_OK) {
Bitmap imageBitmap = (Bitmap) data.getExtras().get("data");
是不是很简单，原理是这样的，通过封装一个RxResultHoldFragment去处理onActivityResult
private IActivityObservable buildActivityObservable() {
T target = targetWeak.get();
if (target instanceof FragmentActivity) {
FragmentActivity activity = (FragmentActivity)
android.support.v4.app.FragmentManager fragmentManager = activity.getSupportFragmentManager();
IActivityObservable activityObservable = RxResultHoldFragmentV4.getHoldFragment(fragmentManager);
return activityO
if (target instanceof Activity) {
Activity activity = (Activity)
FragmentManager fragmentManager = activity.getFragmentManager();
IActivityObservable activityObservable = RxResultHoldFragment.getHoldFragment(fragmentManager);
return activityO
if (target instanceof Context) {
final Context context = (Context)
IActivityObservable activityObservable = new RxResultHoldContext(context);
return activityO
if (target instanceof Fragment) {
Fragment fragment = (Fragment)
FragmentManager fragmentManager = fragment.getFragmentManager();
if (fragmentManager != null) {
IActivityObservable activityObservable = RxResultHoldFragment.getHoldFragment(fragmentManager);
return activityO
if (target instanceof android.support.v4.app.Fragment) {
android.support.v4.app.Fragment fragment = (android.support.v4.app.Fragment)
android.support.v4.app.FragmentManager fragmentManager = fragment.getFragmentManager();
if (fragmentManager != null) {
IActivityObservable activityObservable = RxResultHoldFragmentV4.getHoldFragment(fragmentManager);
return activityO
return new RxResultHoldEmpty();
拦截器是重中之重，有了拦截器可以做好多事情，可以说之所以要做页面路由，就是为了要实现拦截器。是用线程等待实现的，但是现在有Rxjava了，可以实现更优美的方式。
先来看一下我做的拦截器的效果.
@Intercept(path = "/second")
public class SecondInterceptor extends Interceptor {
public void intercept(final Call call) {
Request request = call.getRequest();
final Intent intent = request.getIntent();
Context context = request.getContext();
StringBuffer stringBuffer = new StringBuffer();
stringBuffer.append("Intercept\n");
stringBuffer.append("URL: " + request.getUrl() + "\n");
AlertDialog.Builder builder = new AlertDialog.Builder(context,R.style.Theme_AppCompat_Dialog_Alert);
builder.setTitle("Notice");
builder.setMessage(stringBuffer);
builder.setNegativeButton("cancel", new DialogInterface.OnClickListener() {
public void onClick(DialogInterface dialog, int which) {
call.cancel();
builder.setPositiveButton("ok", new DialogInterface.OnClickListener() {
public void onClick(DialogInterface dialog, int which) {
intent.putExtra("key1", "value3");
call.proceed();
builder.setOnDismissListener(new DialogInterface.OnDismissListener() {
public void onDismiss(DialogInterface dialog) {
call.cancel();
builder.show();
是不是很简单，参考了部分OkHttp的实现思路，加入Rxjava，实现异步拦截。
首先将请求转换成责任链模式RealCallChain,RealCallChain的call方法实际不会执行路由跳转,只有Interceptor里面调用了call.proceed或者call.cancel才会执行.
private Observable&Request& buildRequest() {
RealCallChain chain = new RealCallChain(interceptors, 0, request);
chain.setTimeout(interceptTimeOut);
chain.call();
return chain
.getRequestObservable()
.map(new Func1&Request, Request&() {
public Request call(Request request) {
if (interceptors != null) {
for (Interceptor interceptor : interceptors) {
interceptor.onCall(request);
return request;
接着处理异步的问题，这里用到了Rxjava的AsyncSubject和BehaviorSubject，
AsyncSubject具有仅释放Observable释放的最后一个数据的特性，作为路由请求的发送器BehaviorSubject具有一开始就会释放最近释放的数据的特性，作为路由拦截器的发送器具体实现看核心代码
public void proceed() {
if (index &= interceptors.size()) {
realCall();
final Interceptor interceptor = interceptors.get(index);
Observable
.observeOn(AndroidSchedulers.mainThread())
.subscribe(new Action1&Integer&() {
public void call(Integer integer) {
interceptor.intercept(RealCallChain.this);
interceptorSubject.onNext(interceptor);
index = index + 1;
大部分路由库都是手动拼参数调用路由的，这里模仿了Retrofit接口式调用，受了的启发，不过Retrofit使用了动态代理，我使用的Apt没有性能损耗。
通过Apt生成每个接口的实际方法
譬如把SecondService接口
@Path("/second")
@Activity(SecondActivity.class)
void startSecondActivity();
public final class SecondService$$Provider implements SecondService {
public DeepLinkClient deepLinkC
public SecondService$$Provider(DeepLinkClient deepLinkClient) {
this.deepLinkClient= deepLinkC
public void startSecondActivity() {
Intent intent = new Intent();
intent.setData(Uri.parse("app://deeplink/second"));
Request request = deepLinkClient.buildRequest(intent);
if (request != null) {
request.start();
@Around("execution(* okdeeplink.DeepLinkClient.build(..))")
public Object aroundBuildMethod(ProceedingJoinPoint joinPoint) throws Throwable {
DeepLinkClient target = (DeepLinkClient)joinPoint.getTarget();
if (joinPoint.getArgs() == null || joinPoint.getArgs().length != 1) {
return joinPoint.proceed();
Object arg = joinPoint.getArgs()[0];
if (arg instanceof Class) {
Class buildClass = (Class)
if (buildClass.isAssignableFrom(getClass())) {
return new SecondService$$Provider(target);
return joinPoint.proceed();
SecondService secondServicenew = DeepLinkClient(target).build(SecondService.class);
SecondService就生成了。
为了调用方便，直接在Activity或者fragement写这段代码，sampleServive就自动生成了
SampleService sampleS
但是如果用到MVP模式，不是在Activity里面调用路由，后面会支持在这些类里面自动注入SampleService，现在先用java代码build
大部分路由库都是手动获取参数的，这样还要传入参数key比较麻烦，这里模仿了,不过我支持类型更全一些,支持Bundle支持的所有类型，而且不需要在Acitivty的onCreate调用获取代码。
通过Apt把这段代码
public class MainActivity extends AppCompatActivity {
@Query("key")
public class MainActivity$$Injector {
@Around("execution(* okdeeplink.sample.MainActivity.onCreate(..))")
public void onCreate(ProceedingJoinPoint joinPoint) throws Throwable {
MainActivity target = (MainActivity)joinPoint.getTarget();
Bundle dataBundle = new Bundle();
Bundle saveBundle = (Bundle)joinPoint.getArgs()[0];
Bundle targetBundle = BundleCompact.getSupportBundle(target);
if(targetBundle != null) {
dataBundle.putAll(targetBundle);
if(saveBundle != null) {
dataBundle.putAll(saveBundle);
target.key= BundleCompact.getValue(dataBundle,"key",String.class);
} catch (Exception e) {
e.printStackTrace();
joinPoint.proceed();
@After("execution(* okdeeplink.sample.MainActivity.onSaveInstanceState(..))")
public void onSaveInstanceState(JoinPoint joinPoint) throws Throwable {
MainActivity target = (MainActivity)joinPoint.getTarget();
Bundle saveBundle = (Bundle)joinPoint.getArgs()[0];
Intent intent = new Intent();
intent.putExtra("key",target.key);
saveBundle.putAll(intent.getExtras());
@Around("execution(* okdeeplink.sample.MainActivity.onNewIntent(..))")
public void onNewIntent(ProceedingJoinPoint joinPoint) throws Throwable {
MainActivity target = (MainActivity)joinPoint.getTarget();
Intent targetIntent = (Intent)joinPoint.getArgs()[0];
Bundle dataBundle = targetIntent.getExtras();
target.key= BundleCompact.getValue(dataBundle,"key",String.class);
} catch (Exception e) {
e.printStackTrace();
joinPoint.proceed();
Module接入不同App
这里是参考把path作为key对应activity，这样接入到其他app中，就自动替换了scheme码了
DeepLinkClient.addAddress(new Address("/main", MainActivity.class));
现在有好多人用脚本来打开App，然后干坏事，其实时可以用路由来屏蔽掉.
有三种方法供君选择，不同方法适合不同场景
就是把所有参数加密成一个数据作为sign参数，然后比对校验，但是这要求加密方法不变，要不然升级了以前的app就打不开了
adb打开屏蔽
在android5.1手机上，用adb打开的app它的mReferrer为空
public boolean isStartByAdb(android.app.Activity activity){
if (Build.VERSION.SDK_INT &= 22) {
android.net.Uri uri = ActivityCompat.getReferrer(activity);
return uri == null | TextUtils.isEmpty(uri.toString()) ;
return false;
在Android 4.4手机上, 写了android:ssp的组件，只有特定应用可以打开
android:name="okdeeplink.DeepLinkActivity"
android:noHistory="true"
android:theme="@android:style/Theme.Translucent.NoTitleBar"&
&intent-filter&
&action android:name="android.intent.action.VIEW" /&
&category android:name="android.intent.category.DEFAULT" /&
&category android:name="android.intent.category.BROWSABLE" /&
android:ssp="com.app.test"
android:host="app"
android:scheme="odl" /&
&/intent-filter&
&/activity&
这三种方法，比较适合的还是签名校验为主，adb过滤为副
如何解决路由造成的Activity堆栈错乱的问题
activity的launchMode使用不当会照成闪屏页面打开多次的问题，可以参考我这篇。
路由是一个基础模块，技术难度虽然不是很大，但是如果每个开发都重新踩一遍，性价比就比较低，我希望能把路由相关的所有链路都替你弄好，你可以留着时间去干其他更重要的事情，譬如陪陪家人，逗逗狗什么的。
接下来我会在这几个方面努力，把整条链路补全。
做一个像Swagger的平台，支持一键导出所有路由、二维码打开路由注解修改AndroidManifest，不再需要路由表支持路由方法接收器，Url直接打开某个方法，不再局限Activity已实现如果大家有意见，欢迎联系我
模仿retrofit，各个业务分根据需求约定好接口，就像一份接口文档一样
讨论了android里面原生支持找到路由来源的可能性，分析了referrer是如何产生的
提供了一种hook activitythread找到launchedFromPackage的方法，不过也只支持5.0以上
只有包含特定Package URL的 intent 才会唤起页面
没有更多推荐了，