03.app保活解决方案

最新推荐文章于 2024-04-30 14:51:57 发布
最新推荐文章于 2024-04-30 14:51:57 发布
阅读量198 收藏
点赞数
文章标签： 移动开发 java
原文链接：https://yq.aliyun.com/articles/657340
版权

最近针对我们项目中app经常收不到推送的问题作了一些处理，增加app的保活管理。我们知道当安卓进程退到后台之后，很容易被系统杀死，这个时候推送消息一般都是收不到的。我也观察了一些比较主流的app,像同花顺，钉钉，甚至是支付宝我都很少在后台收到过消息，尤其是支付宝计步功能老是不准，很有可能就是这种问题导致的

当然没有百分之百可以实现保活的解决方案，即便是从ndk层面去进行，但至少我们要尽一些努力，我采用的是双进程守护+1像素Activity的实现方式

双进程守护：

开启两个service，分别在两个进程中运行，启动一个service时，通过aidl的方式将它和另一个service绑定在一起，当其中一个service被杀掉的时候，另一个service中重新将它启动

service1启动绑定service2

@Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        //提高进程优先级
        startForeground(GuardServiceId2,new Notification());
        //绑定建立链接
        bindService(new Intent(getApplicationContext(),GuardService2.class),connection, Context.BIND_IMPORTANT);
        return START_STICKY;
    }

service1和service2的链接断开时，说明service2被杀死，这时重新绑定

private ServiceConnection connection = new ServiceConnection() {
        @Override
        public void onServiceConnected(ComponentName componentName, IBinder iBinder) {
            ArLog.i("TAG", "connect to guardservice2");
        }

        @Override
        public void onServiceDisconnected(ComponentName componentName) {
            // 断开链接 ,重新启动，重新绑定
            startService(new Intent(getApplicationContext(), GuardService2.class));
            bindService(new Intent(getApplicationContext(),GuardService2.class),connection, Context.BIND_IMPORTANT);
            ArLog.i("TAG", "disconnect from guardservice2");
        }
    };

service2绑定service1的逻辑同上

这样一来，基本上在一定程度上可以保证app常驻内存了，保险起见，我们再加一层保护，创建两个JobService
分别位于上边两个进程中（安卓5.0以上适用），开启一个轮巡任务不断的检查service存活情况，如果不在了，启动它，注意JobService需要权限

<uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED" />

@Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        // 开启一个轮寻
        JobScheduler jobScheduler = (JobScheduler) getSystemService(Context.JOB_SCHEDULER_SERVICE);
        JobInfo.Builder jobBuilder = new JobInfo.Builder(jobId,new ComponentName(this,JobWakeUpService1.class));
        //设置每两秒钟一次
        jobBuilder.setPeriodic(2000);
        jobScheduler.schedule(jobBuilder.build());
        ArLog.i("TAG", "start JobWakeUpService1");
        return START_STICKY;
    }

    @Override
    public boolean onStartJob(JobParameters jobParameters) {
        // 开启定时任务，定时轮寻 ， 看MessageService有没有被杀死
        // 如果杀死了启动  轮寻onStartJob

        // 判断服务有没有在运行
        boolean messageServiceAlive = serviceAlive(GuardService1.class.getName());
        if(!messageServiceAlive){
            ArLog.i("TAG", "GuardService1 is killed ，restart it");
            startService(new Intent(this,GuardService1.class));
        }
        boolean JobWakeUpService2Alive = serviceAlive(JobWakeUpService2.class.getName());
        if(!JobWakeUpService2Alive){
            ArLog.i("TAG", "JobWakeUpService2 is killed ，restart it");
            startService(new Intent(this,JobWakeUpService2.class));
        }
        return false;
    }

1像素Activity：

监听系统锁屏消息，在屏幕锁定的时候开启一个Activity，这个Activity只有一个像素大小，当屏幕开启的时候再关闭这个Activity，达到app一直位于前台进程的目的，提高进程的优先级，降低系统杀死app的概率,在这个Activity启动时设置app只有一个像素大小，既可以减少占用空间，也可以防止开锁屏期间被用户发现这个奇怪的页面

        Window window = getWindow();
        window.setGravity(Gravity.LEFT & Gravity.TOP);
        WindowManager.LayoutParams attributes = window.getAttributes();
        attributes.x = 0;
        attributes.y = 0;
        attributes.width = 1;
        attributes.height = 1;
        window.setAttributes(attributes);

在AndroidManifest中配置

<activity android:name=".general.guard.DaemonActivity"
            android:configChanges="keyboardHidden|orientation|screenSize|navigation|keyboard"
            android:excludeFromRecents="true"
            android:exported="false"
            android:finishOnTaskLaunch="false"
            android:launchMode="singleInstance"
            android:theme="@style/DaemonActivityStyle"/>

完整代码：

GuardService1

public class GuardService1 extends Service {
    private final int GuardServiceId2 = 2;
    @Override
    public void onCreate() {
        super.onCreate();
        ArLog.i("TAG", "GuardService1 wait for signal");
    }
    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        //提高进程优先级
        startForeground(GuardServiceId2,new Notification());
        //绑定建立链接
        bindService(new Intent(getApplicationContext(),GuardService2.class),connection, Context.BIND_IMPORTANT);
        return START_STICKY;
    }
    @Override
    public IBinder onBind(Intent intent) {
        return new GuardAIDL.Stub(){};
    }
    private ServiceConnection connection = new ServiceConnection() {
        @Override
        public void onServiceConnected(ComponentName componentName, IBinder iBinder) {
            ArLog.i("TAG", "connect to guardservice2");
        }
        @Override
        public void onServiceDisconnected(ComponentName componentName) {
            // 断开链接 ,重新启动，重新绑定
            startService(new Intent(getApplicationContext(), GuardService2.class));
            bindService(new Intent(getApplicationContext(),GuardService2.class),connection, Context.BIND_IMPORTANT);
            ArLog.i("TAG", "disconnect from guardservice2");
        }
    };
    @Override
    public void onDestroy() {
        ArLog.i("TAG", "guardservice2 is onDestroy");
        unbindService(connection);
        super.onDestroy();
    }
}

GuardService2

public class GuardService2 extends Service {
    private final int GuardServiceId1 = 1;
    @Override
    public void onCreate() {
        super.onCreate();
        ArLog.i("TAG", "GuardService2 wait for signal");
    }
    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        //提高进程优先级
        startForeground(GuardServiceId1,new Notification());
        //绑定建立链接
        bindService(new Intent(getApplicationContext(),GuardService1.class),connection, Context.BIND_IMPORTANT);
        return START_STICKY;
    }
    @Override
    public IBinder onBind(Intent intent) {
        return new GuardAIDL.Stub(){};
    }
    private ServiceConnection connection = new ServiceConnection() {
        @Override
        public void onServiceConnected(ComponentName componentName, IBinder iBinder) {
            ArLog.i("TAG", "connect to guardservice1");
        }
        @Override
        public void onServiceDisconnected(ComponentName componentName) {
            // 断开链接 ,重新启动，重新绑定
            startService(new Intent(getApplicationContext(), GuardService1.class));
            bindService(new Intent(getApplicationContext(),GuardService1.class),connection, Context.BIND_IMPORTANT);
            ArLog.i("TAG", "disconnect from guardservice1");
        }
    };
    @Override
    public void onDestroy() {
        ArLog.i("TAG", "guardservice1 is onDestroy");
        unbindService(connection);
        super.onDestroy();
    }
}

JobWakeUpService1

@RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
public class JobWakeUpService1 extends JobService {
    private int jobId = 12;
    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        // 开启一个轮寻
        JobScheduler jobScheduler = (JobScheduler) getSystemService(Context.JOB_SCHEDULER_SERVICE);
        JobInfo.Builder jobBuilder = new JobInfo.Builder(jobId,new ComponentName(this,JobWakeUpService1.class));
        //设置每两秒钟一次
        jobBuilder.setPeriodic(2000);
        jobScheduler.schedule(jobBuilder.build());
        ArLog.i("TAG", "start JobWakeUpService1");
        return START_STICKY;
    }
    @Override
    public boolean onStartJob(JobParameters jobParameters) {
        // 开启定时任务，定时轮寻 ， 看MessageService有没有被杀死
        // 如果杀死了启动  轮寻onStartJob
        // 判断服务有没有在运行
        boolean messageServiceAlive = serviceAlive(GuardService1.class.getName());
        if(!messageServiceAlive){
            ArLog.i("TAG", "GuardService1 is killed ，restart it");
            startService(new Intent(this,GuardService1.class));
        }
        boolean JobWakeUpService2Alive = serviceAlive(JobWakeUpService2.class.getName());
        if(!JobWakeUpService2Alive){
            ArLog.i("TAG", "JobWakeUpService2 is killed ，restart it");
            startService(new Intent(this,JobWakeUpService2.class));
        }
        return false;
    }
    @Override
    public boolean onStopJob(JobParameters jobParameters) {
        return false;
    }
    /**
     * 判断某个服务是否正在运行的方法
     * @param serviceName
     *            是包名+服务的类名（例如：net.loonggg.testbackstage.TestService）
     * @return true代表正在运行，false代表服务没有正在运行
     */
    private boolean serviceAlive(String serviceName) {
        boolean isWork = false;
        ActivityManager myAM = (ActivityManager)getSystemService(Context.ACTIVITY_SERVICE);
        List<ActivityManager.RunningServiceInfo> myList = myAM.getRunningServices(100);
        if (myList.size() <= 0) {
            return false;
        }
        for (int i = 0; i < myList.size(); i++) {
            String mName = myList.get(i).service.getClassName().toString();
            if (mName.equals(serviceName)) {
                isWork = true;
                break;
            }
        }
        return isWork;
    }
}

JobWakeUpService2

@RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
public class JobWakeUpService2 extends JobService {
    private int jobId = 13;
    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        // 开启一个轮寻
        JobScheduler jobScheduler = (JobScheduler) getSystemService(Context.JOB_SCHEDULER_SERVICE);
        JobInfo.Builder jobBuilder = new JobInfo.Builder(jobId,new ComponentName(this,JobWakeUpService2.class));
        //设置每两秒钟一次
        jobBuilder.setPeriodic(2000);
        jobScheduler.schedule(jobBuilder.build());
        ArLog.i("TAG", "start JobWakeUpService2");
        return START_STICKY;
    }
    @Override
    public boolean onStartJob(JobParameters jobParameters) {
        // 开启定时任务，定时轮寻 ， 看MessageService有没有被杀死
        // 如果杀死了启动  轮寻onStartJob
        // 判断服务有没有在运行
        boolean messageServiceAlive = serviceAlive(GuardService2.class.getName());
        if(!messageServiceAlive){
            ArLog.i("TAG", "GuardService2 is killed ，restart it");
            startService(new Intent(this,GuardService1.class));
        }
        boolean JobWakeUpService1Alive = serviceAlive(JobWakeUpService1.class.getName());
        if(!JobWakeUpService1Alive){
            ArLog.i("TAG", "JobWakeUpService1 is killed ，restart it");
            startService(new Intent(this,JobWakeUpService1.class));
        }
        return false;
    }
    @Override
    public boolean onStopJob(JobParameters jobParameters) {
        return false;
    }
   /**
     * 判断某个服务是否正在运行的方法
     * @param serviceName
     *            是包名+服务的类名（例如：net.loonggg.testbackstage.TestService）
     * @return true代表正在运行，false代表服务没有正在运行
     */
    private boolean serviceAlive(String serviceName) {
        boolean isWork = false;
        ActivityManager myAM = (ActivityManager)getSystemService(Context.ACTIVITY_SERVICE);
        List<ActivityManager.RunningServiceInfo> myList = myAM.getRunningServices(100);
        if (myList.size() <= 0) {
            return false;
        }
        for (int i = 0; i < myList.size(); i++) {
            String mName = myList.get(i).service.getClassName().toString();
            if (mName.equals(serviceName)) {
                isWork = true;
                break;
            }
        }
        return isWork;
    }
}

DaemonActivity

public class DaemonActivity extends AppCompatActivity {
    private static final java.lang.String TAG = "DaemonActivity";
    private static DaemonActivity context;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        this.context = this;
        Window window = getWindow();
        window.setGravity(Gravity.LEFT & Gravity.TOP);
        WindowManager.LayoutParams attributes = window.getAttributes();
        attributes.x = 0;
        attributes.y = 0;
        attributes.width = 1;
        attributes.height = 1;
        window.setAttributes(attributes);
    }
    /**
     * 监听手机的锁屏和开屏广播，锁屏后调用start开启这个activity
     * 调用此方法时，activity未启动，不能使用this.context,只能用application的
     */
    public static void startDaemon(){
        Intent intent = new Intent(SightPlusApplication.getContext(),DaemonActivity.class);
        intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
        SightPlusApplication.getContext().startActivity(intent);
        ArLog.i(TAG,"startDaemon");
    }
    /**
     * 监听手机的锁屏和开屏广播，开屏后调用stop销毁这个activity
     * 调用此方法时，可以使用activity的context
     */
    public static void stopDaemon(){
        if (context != null){
            ArLog.i(TAG,"stopDaemon");
            context.finish();
        }
    }
}

AndroidManifest配置

<!--双进程守护-->
        <service
            android:name="cn.easyar.sightplus.general.guard.GuardService1"
            android:enabled="true"
            android:exported="true"
            android:process=":Service1" />
        <service
            android:name="cn.easyar.sightplus.general.guard.GuardService2"
            android:enabled="true"
            android:exported="true"
            android:process=":Service2" />
        <service
            android:name="cn.easyar.sightplus.general.guard.JobWakeUpService1"
            android:enabled="true"
            android:exported="true"
            android:process=":Service1"
            android:permission="android.permission.BIND_JOB_SERVICE" />

        <service
            android:name="cn.easyar.sightplus.general.guard.JobWakeUpService2"
            android:enabled="true"
            android:exported="true"
            android:process=":Service2"
            android:permission="android.permission.BIND_JOB_SERVICE" />
        <!--1像素Activity-->
        <activity android:name=".general.guard.DaemonActivity"
            android:configChanges="keyboardHidden|orientation|screenSize|navigation|keyboard"
            android:excludeFromRecents="true"
            android:exported="false"
            android:finishOnTaskLaunch="false"
            android:launchMode="singleInstance"
            android:theme="@style/DaemonActivityStyle"/>

增加一个管理类GuardAppManager一键启动和关闭

public class GuardAppManager {
    private GuardAppManager(){}
    private static volatile GuardAppManager mInstance;
    private BootCompleteReceiver mReceiver;

    public static GuardAppManager getInstance(){
        if (mInstance == null){
            synchronized (GuardAppManager.class){
                if (mInstance == null){
                    return new GuardAppManager();
                }
            }
        }
        return mInstance;
    }
    public class BootCompleteReceiver extends BroadcastReceiver {
        @Override public void onReceive(Context context, Intent intent) {
            if(intent.getAction().equals(Intent.ACTION_SCREEN_OFF)) {
                ArLog.i("TAG","ACTION_SCREEN_OFF");
                DaemonActivity.startDaemon();
            }
            else if(intent.getAction().equals(Intent.ACTION_SCREEN_ON)){
                ArLog.i("TAG","ACTION_SCREEN_ON");
                DaemonActivity.stopDaemon();
            }
        }
    }
    /**
     * 开启守护
     * @param context
     */
    public void start(Context context){
        context.startService(new Intent(context, GuardService1.class));
        context.startService(new Intent(context, GuardService2.class));
        if(Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP){
            //必须大于5.0
            context.startService(new Intent(context,JobWakeUpService2.class));
            context.startService(new Intent(context,JobWakeUpService1.class));
        }
        IntentFilter filter = new IntentFilter();
        filter.addAction(Intent.ACTION_SCREEN_ON);
        filter.addAction(Intent.ACTION_SCREEN_OFF);
        mReceiver = new BootCompleteReceiver();
        context.registerReceiver(mReceiver,filter);
    }
    /**
     * 关闭守护
     * @param context
     */
    public void stop(Context context){
        if (mReceiver != null){
            context.unregisterReceiver(mReceiver);
        }
    }
}

开启守护

GuardAppManager.getInstance().start(this);

关闭守护

GuardAppManager.getInstance().stop(this);
weixin_34007886
关注
安卓APP保活--十种方案
半夏微凉科技
11-21 4299
安卓APP保活--十种方案 什么是保活？保活就是在用户主动杀进程，或者系统基于当前内存不足状态而触发清理进程后，该进程设法让自己免于被杀的命运或者被杀后能立刻重生的手段。 保活是”应用的蜜罐，系统的肿瘤“，应用高保活率给自己赢得在线时长，甚至做各种应用想做而用户不期望的行为，给系统带来的是不必要的耗电，以及系统额外的性能负担。 保活方案一直就层出不穷，APP开发们不断地绞尽脑汁让自己的应用能存活得时间更长， 主要思路有两个：
uniapp：APP开发，后台保活
mosowe
09-14 7430
在ios中，软件切换至后台、手机息屏，过了十来秒软件就会被系统挂起，APP内的任务就不能继续执行；在android中，默认情况下，软件在后台运行的时候，触发某些特定条件的情况下，会被杀掉进程。
Android应用保活全攻略：30个实用技巧助你突破后台限制
陆业聪
03-26 2736
本文详细介绍了30种保活方法，涵盖了前台服务、双进程守护、JobScheduler、监听系统广播、使用Firebase Cloud Messaging等多种技巧。同时，文章强调了在实际开发中，应根据功能需求和用户体验来权衡保活策略，尽量遵循系统的规范和限制。在可能的情况下，优先考虑使用系统推荐的解决方案，以实现最佳的用户体验。
Android 给App保活（10种方案）
热门推荐
zhang_senlin的博客
08-07 1万+
1.Activity 1像素保活 public class Activity1 extends AppCompatActivity { @Override protected void onCreate(@Nullable Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_1); Window
Android应用的保活方案以及另类出路，你了解几个
m0_57699778的博客
06-03 400
前言 我们在做Android应用的时候都知道，必须要有一套好的保活方案，这样应用的push到达率高，应用的活跃度也就很高，我们平时也可以发现很多应用我们明明已经关闭了，但是还是可以接收到push消息，或者ps查看进程还是存在的。当然现在已经有很多方案在做这件事了，但是有一个问题就是像微信中及时接受消息的应用如果系统把他强杀之后接收不到消息，用户也是要疯掉的，所以系统厂商会给出一个白名单有一些应用是不会强杀的。一 一、常见保活方案 **1、监听广播：**监听全局的静态广播，比如时间更新的广播、开机广播、
Android App保活的方式
小魔楼的专栏
06-06 1万+
以上是Android App保活的一些常用方式，不同的应用程序可以根据自己的需求选择合适的方式来保持应用程序的运行状态。需要注意的是，保活过程中需要合理使用系统资源，以避免对系统性能造成影响。
keepalive.zip，app保活策略
05-11
"keepalive.zip"这个压缩包提供的就是一个关于Android App保活的解决方案。 首先，"保活"在Android开发中指的是防止App被系统强制关闭或者暂停，以维持其在后台的服务、定时任务或者关键功能的正常运行。通常，...
app保活机制.zip
06-08
本压缩包包含三个补丁文件：01-新增自研app保活机制.patch、02-新增自研app保活机制.patch、03-新增自研app保活机制.patch，这些文件很可能提供了逐步实现或优化app保活功能的代码修改方案。 1. **保活机制概述**：...
Android进程保活主流方案
最新发布
2401_84520150的博客
04-30 682
面试是一个不断学习、不断自我提升的过程，有机会还是出去面面，至少能想到查漏补缺效果，而且有些知识点，可能你自以为知道，但让你说，并不一定能说得很好。有些东西有压力才有动力，而学到的知识点，都是钱（因为技术人员大部分情况是根据你的能力来定级、来发薪水的），技多不压身。附上我的面试各大专题整理： 面试指南，满满的都是干货，希望对大家有帮助！网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。需要这份系统化学习资料的朋友，可以戳这里获取。
什么是Android进程（app）保活、进程保活的方案
lxm920714的专栏
03-08 4138
想了解什么是Android 进程、Android 进程的生命周期、Android 进程回收策略 可参照地址什么是Android 进程、Android 进程的生命周期、Android 进程回收策略_lmm0513的博客-CSDN博客_android进程是什么 一、app保活 在Android中是一种流氓行为，一方面无端浪费用户手机电量，另一方面给用户一种很困惑的感觉，影响用户体验还有可能导致整个Android系统流畅性变差，所以Google官方一种不推荐该功能，也一直在阻止这方面功能在An...
详解Android 8.0以上系统应用如何保活
01-05
最近在做一个埋点的sdk，由于埋点是分批上传的，不是每次都上传，所以会有个进程保活的机制，这也是自研推送的实现技术之一：如何保证Android进程的存活。 对于Android来说，保活主要有以下一些方法： 开启前台Service（效果好，推荐） Service中循环播放一段无声音频（效果较好，但耗电量高，谨慎使用） 双进程守护（Android 5.0前有效） JobScheduler（Android 5.0后引入，8.0后失效） 1 像素activity保活方案（不推荐） 广播锁屏、自定义锁屏（不推荐） 第三方推送SDK唤醒（效果好，缺点是第三方接入） 下面是具体的
Android正确的保活方案，不要掉进保活需求死循环陷进
chuyouyinghe的专栏
03-17 1924
在开始前，还是给大家简单介绍一下，以前出现过的一些黑科技： 大概在6年前Github中出现过一个叫MarsDaemon，这个库通过双进程守护的方式实现保活，一时间风头无两。好景不长，进入 Android 8.0时代之后，这个库就废掉了。 最近2年Github上面出来一个Leoric 感兴趣的可以去看一下源码，谁敢用在生产环境呢，也就自己玩玩的才会用吧(不能因为保活而导致手机卡巴斯基)，我没有试过这个，我想说的是：黑科技能黑的了一时，能黑的了一世吗？ 没有规矩，不成方圆，要提升产品的存活率，最终还是..
史上最强Android保活思路：深入剖析腾讯TIM的进程永生技术
Android技术之家
12-04 1256
1、引言随着Android系统的不断升级，即时通讯网技术群和社区里的IM和推送开发的程序员们，对于进程保活这件事是越来越悲观，必竟系统对各种保活黑科技的限制越来越多了，想超越系统的挚肘，...
Android 原生保活
shi450561200的博客
02-04 3708
Android保活众所周知，完全保活除非加入白名单，否则只能保住一段时间。下面一一介绍Android保活方案。由于时间有限，保活方案文章的编写，采用的是逐步完善的方式。在保证内容可用的条件下逐步晚上文字，不足之处还请见谅。android:name="com.xiaoya.keepalive.KeepServices"// 找到自己的服务路径。a、首先在AndroidManifest.xml添加以下权限。c、在AndroidManifest.xml中注册服务。
App保活攻防仗
习伏众，神巧者不过习者之门
02-08 487
五一小长假，老板特意让我去研究下Andorid黑屏如何保证app不被杀掉。 一、为什么要保活？ 保活的源头是因为我们希望自己的进程或服务能够一直在后台运行，但是总有各种各样的原因导致我们希望破灭。 失活的原因 1、触发Android内存回收机制 Android系统内存不足时，系统会杀掉一部分进程以释放空间，保证系统使用流畅。谁生谁死的这个生死大权就是由LMK所决定的，Andr...
这些分析加上这13道面试题，面试足矣
Android_SE的博客
03-19 1147
前言 其实对于很多人来说，都和我原来有同样一个疑虑：**到底去大厂还是创业型公司？**去大公司一个萝卜一个坑，要往上走需要运气+实力足够好才能脱颖而出，创业型公司，可能更容易实现自己的想法和舞台，能把能力表现的淋漓尽致，可是会碰到更多的问题，公司经营不下去了怎么办？薪资待遇不如大厂？ 一丶大厂offer？ 我相信每个程序员的梦想都是得到大厂的offer，我觉得这很正常，这并不是我们的饭后谈资而是每...
房地产行业数字化售楼解决方案：APP移动售楼系统
"房地产行业APP解决方案" 本文将详细介绍房地产行业APP解决方案，特别是四川亿翰通科技有限公司提供的定制APP技术方案。此类APP旨在提升房地产销售与推广的效率，通过集成先进的数字图像技术，如虚拟仿真、互动...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值