mobileInsight-mobile Overview¶

if __name__ == "__main__":
    try:
        """
        Run MobileInsight normally
        """
        MobileInsightApp().run()
    except Exception, e:
        """
        Bug/error occurs when running MobileInsight.
        We will launch crash report feature, and ask user if they want to upload bug report to our server
        """
        import traceback,crash_app
        print str(traceback.format_exc())
        crash_app.CrashApp().run()

class MobileInsightApp(App):

    def build_settings(self, settings):
        """
        Load default setting panels for MobileInsight (using kivy's settings.add_json_panel feature).
        This is a built-in function in kivy.App
        """

    def create_app_settings(self,config,settings):
        """
        Load setting panels for each plugin.
        In MobileInsight, each plugin can define its own setting panel by defining a settings.json.
        More details can be found in this tutorial:
        http://metro.cs.ucla.edu/mobile_insight/tutorial-plugin.html

        At runtime, MobileInsight will launch settings.json in each plugin, and synthesis a uniformed setting pannel.
        """

    def build_config(self, config):
        """
        Load default values of the default settings for MobileInsight.
        This is a built-in function in kivy.App
        """

    def create_app_default_config(self, config):
        """
        Load default values of the default settings for each plugin.
        """

    def build(self):

        """
        This is a built-in function in kivy.App.
        In this function, we specify the major kivy.Screen UI.
        Currently we load two UIs (subclass of kivy.Screen):
            - MobileInsightScreen: this screen encapsulates MobileInsight's major functions
            - LogViewerScreen: this screen specifies in-app log viewer
        Then we set MobileInsightScreen as the main screen.
        """

    def on_pause(self):
        """
        Built-in function in kivy.App.
        It will be called when users switch to other apps.
        In this function, we did cleanup tasks and tricks to prevent some python-for-android bugs.
        Reference: https://kivy.org/docs/api-kivy.app.html#kivy.app.App.on_pause
        """

    def check_update(self):
        """
        Check if new MobileInsight update is available.
        It will launch check_update function
        """

    def on_start(self):
        """
        Built-in function in kivy.App.
        It will be called when MobileInsight is launched.
        In this function, we will check for software update (if user specifies so in the setting panel)
        Reference: https://kivy.org/docs/api-kivy.app.html#kivy.app.App.on_start
        """

class MobileInsightScreen(Screen):

    def __init__(self,name):
        """
        Initialization function. We will do the following task (in order):
            1. Check if the device is rooted
            2. Initialize necessary libs required by MobileInsight (e.g., libwireshark)
            3. Check if Android's security policy allows MobileInsight to access diagnostic mode.
            This is mainly caused by SELinux
            4. Create necessary folders on SDcard (e.g., /sdcard/mobile_insight/, /sdcard/mobile_insight/log/)
            5. Load built-in and 3rd-party plugins (located in /sdcard/mobile_insight/apps/)
            6. Check if the diagnostic mode is enabled
            7. Load configurations from the setting panel (configs stored in /sdcard/.mobileinsight.ini)
        """

    def __check_security_policy(self):
        """
        Update SELinux policy.
        For Nexus 6/6P, the SELinux policy may forbids the log collection.
        """

    def __check_diag_mode(self):
        """
        Check if diagnostic mode is enabled.
        """

    def __init_libs(self):
        """
        Initialize libs required by MobileInsight.
        These libs will be copied to /system/lib and /system/bin, respectively
        """

    def start_service(self, app_name):
        """
        Launch the plugin selected by the user.
        app_name specifies the name of the plugin selected by user.
        In this code, it will use the code in demo_app/service to launch the plugin as Android service.
        """

    def stop_service(self):
        """
        Stop the Android service if user clicks "Stop" button
        """

    def about(self):
        """
        Popup the "About" panel when user clicks "About" button
        """

    """
    The following functions are used for on-screen logging purpose with different levels.
    """
    def log_info(self, msg):
    def log_warning(self, msg):
    def log_error(self, msg):
    def append_log(self, s):
    def show_log(self):

def start_service(self, app_name):
    if platform == "android" and app_name in self.app_list:
        if self.service:
            # stop the running service
            self.stop_service()

        from android import AndroidService
        self.error_log = "Running " + app_name + "..."
        self.service = AndroidService("MobileInsight is running...", app_name)
        self.service.start(app_name+":"+self.app_list[app_name][0])   # app name
        self.default_app_name = app_name

    else:
        self.error_log = "Error: " + app_name + "cannot be launched!"

# In mobileInsight-mobile/demo_app/service/main.py

if __name__ == "__main__":
        arg = os.getenv("PYTHON_SERVICE_ARGUMENT")  # get the argument passed

        tmp = arg.split(":")
        if len(tmp)<2:
            raise AssertionError("Error: incorrect service path:"+arg)
        app_name = tmp[0]
        app_path = tmp[1]

        namespace = {"service_context": mi2app_utils.get_service_context()}

        #Load configurations as global variables
        config = ConfigParser()
        config.read('/sdcard/.mobileinsight.ini')

       # Set global variable plugin_config for the plugin
       # This way, users can get configurations by calling plugin_config[PARA_NAME]
        namespace["plugin_config"] = plugin_config

        execfile(app_file, namespace)