MXRAdminAppMessenger.java

Go to the documentation of this file.

/*
 * Copyright 2023 Mighty Immersion, Inc. All Rights Reserved.
 */
package com.managexr.getserialsample;
 
 
import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.ServiceConnection;
import android.content.SharedPreferences;
import android.content.pm.PackageInfo;
import android.content.pm.PackageManager;
import android.os.Bundle;
import android.os.Handler;
import android.os.IBinder;
import android.os.Message;
import android.os.Messenger;
import android.os.RemoteException;
import android.util.Log;
 
import androidx.annotation.NonNull;
 
import org.apache.commons.lang3.StringEscapeUtils;
import org.json.JSONObject;
 
import java.util.List;
 
public class MXRAdminAppMessenger {
    public static class AdminAppMessageTypes {
        public static final int REGISTER_CLIENT = 0;
        public static final int GET_DEVICE_STATUS = 5;
        public static final int DEVICE_STATUS = 5000;
    }
 
    public interface BindStatusListener {
        void onBindStatusChanged(boolean bound);
    }
 
    public interface SerialListener {
        void onSerialUpdated(String serial);
    }
 
    private final static String TAG = "MXRAdminAppMessenger";
    private final static String ADMIN_SERVICE_CLASS_NAME = "com.mightyimmersion.mightyplatform.AdminService";
 
    private final Messenger incomingMessenger = new Messenger(new IncomingMessageHandler());
    private Messenger outgoingMessenger;
    private boolean bound;
    private final Context context;
    private BindStatusListener bindStatusListener;
    private SerialListener serialListener;
 
    private final int CHECK_BINDING_FREQUENCY = 60 * 1000; // 1 minute
    private final Handler checkBindingHandler = new Handler();
 
    public MXRAdminAppMessenger(Context _context) {
        context = _context;
        startBindToAdminServiceLoop();
    }
 
    public void onBindStatusUpdated(BindStatusListener _listener) {
        bindStatusListener = _listener;
    }
 
    public void onSerialUpdated(SerialListener _listener) {
        serialListener = _listener;
        String knownSerial = getSerial();
        if (knownSerial != null) serialListener.onSerialUpdated(knownSerial);
    }
 
    public boolean isManaged() {
        return getInstalledAdminAdminServiceComponent() != null;
    }
 
    public boolean isBound() {
        return bound;
    }
 
    public String getSerial() {
        return getSharedPrefs().getString("serial", null);
    }
 
    private void updateSerial(@NonNull String serial) {
        String currentSerial = getSerial();
        if (serial.equals(currentSerial)) return;
 
        SharedPreferences prefs = getSharedPrefs();
        SharedPreferences.Editor prefsEditor = prefs.edit();
        prefsEditor.putString("serial", serial);
        prefsEditor.apply();
 
        serialListener.onSerialUpdated(serial);
    }
 
    private SharedPreferences getSharedPrefs() {
        return context.getSharedPreferences(context.getPackageName() + ".managexr_prefs", Context.MODE_PRIVATE);
    }
 
    class IncomingMessageHandler extends Handler {
        @Override
        public void handleMessage(Message msg) {
            try {
                Bundle bundle = msg.getData();
                if (msg.what == AdminAppMessageTypes.DEVICE_STATUS) {
                    String deviceStatusJsonString = bundle.getString("json", null);
                    if (deviceStatusJsonString == null) return;
                    JSONObject deviceStatusJson = new JSONObject(removeQuotesAndUnescape(deviceStatusJsonString));
                    String serial = deviceStatusJson.getString("serial");
                    if (serial.length() > 0) updateSerial(serial);
 
                }
            } catch (Exception e) {
                Log.v(TAG, "Failed to parse json: " + e.getMessage());
                e.printStackTrace();
            }
        }
    }
 
    private String removeQuotesAndUnescape(String uncleanJson) {
        String noQuotes = uncleanJson.replaceAll("^\"|\"$", "");
        return StringEscapeUtils.unescapeJava(noQuotes);
    }
 
    // Code below this section is for binding to and maintaining communication with the ManageXR
    // Admin App.
 
    public void startBindToAdminServiceLoop() {
        bindToAdminServiceLoop();
    }
 
    protected void bindToAdminServiceLoop() {
        tryBindToAdminService();
        checkBindingHandler.postDelayed(this::bindToAdminServiceLoop, CHECK_BINDING_FREQUENCY);
    }
 
    private void tryBindToAdminService() {
        if (bound) return;
        Log.v(TAG, "tryBindToAdminService");
 
        ComponentName adminServiceComponent = getInstalledAdminAdminServiceComponent();
        if (adminServiceComponent != null) {
            launchAdminAppServiceIfNeeded(adminServiceComponent.getPackageName());
            Intent bindIntent = new Intent();
            bindIntent.setComponent(adminServiceComponent);
            // This will bind to the service whether or not it is running. As soon as the service is
            // started the onServiceConnected method will fire.
            context.bindService(bindIntent, mConnection, 0);
        } else {
            Log.v(TAG, "ManageXR Admin App not installed or QUERY_ALL_PACKAGES permissions was not added to the manifest!");
        }
    }
 
    private void unbindFromAdminService() {
        context.unbindService(mConnection);
    }
 
    private final ServiceConnection mConnection = new ServiceConnection() {
        public void onServiceConnected(ComponentName className, IBinder service) {
            Log.v(TAG, "onServiceConnected");
            outgoingMessenger = new Messenger(service);
            bound = true;
            boolean registeredAsClient = registerAsClient();
            if (registeredAsClient) {
                Log.v(TAG, "Registered as client");
                if (bindStatusListener != null) bindStatusListener.onBindStatusChanged(true);
                getDeviceStatusAsync();
            } else {
                Log.e(TAG, "Failed to register as client. Unbinding...");
                unbindFromAdminService();
            }
        }
 
        public void onServiceDisconnected(ComponentName className) {
            Log.v(TAG, "onServiceDisconnected");
            outgoingMessenger = null;
            bound = false;
            if (bindStatusListener != null) bindStatusListener.onBindStatusChanged(false);
        }
    };
 
    private boolean registerAsClient() {
        return sendMessage(AdminAppMessageTypes.REGISTER_CLIENT);
    }
 
    public boolean getDeviceStatusAsync() {
        return sendMessage(AdminAppMessageTypes.GET_DEVICE_STATUS);
    }
 
    public boolean sendMessage(int what) {
        return sendMessage(what, null);
    }
 
    public boolean sendMessage(int what, String jsonString) {
        if (!bound) {
            tryBindToAdminService();
            return false;
        }
 
        Message msg = Message.obtain(null, what);
        msg.replyTo = incomingMessenger;
 
        if (jsonString != null) {
            Bundle bundle = new Bundle();
            bundle.putString("json", jsonString);
            msg.setData(bundle);
        }
 
        try {
            outgoingMessenger.send(msg);
        } catch (RemoteException e) {
            Log.e(TAG, e.getMessage());
            return false;
        }
        return true;
    }
 
    private ComponentName getInstalledAdminAdminServiceComponent() {
        PackageManager pm = context.getPackageManager();
        List<PackageInfo> packages = pm.getInstalledPackages(0);
 
        for (PackageInfo packageInfo : packages) {
            if (packageInfo.packageName.startsWith("com.mightyimmersion.mightyplatform.adminapp") && !packageInfo.packageName.contains("preload")) {
                return new ComponentName(packageInfo.packageName, ADMIN_SERVICE_CLASS_NAME);
            }
        }
        return null;
    }
 
    private void launchAdminAppServiceIfNeeded(String packageName) {
        Intent intent = new Intent();
        intent.setClassName(packageName, ADMIN_SERVICE_CLASS_NAME);
        context.startForegroundService(intent);
    }
}