tools/interfaces/IPlatform.py

   1 import gbinder
   2 import logging
   3 import time
   4 from tools import helpers
   5
   6
   7 INTERFACE = "lineageos.waydroid.IPlatform"
   8 SERVICE_NAME = "waydroidplatform"
   9
  10 TRANSACTION_getprop = 1
  11 TRANSACTION_setprop = 2
  12 TRANSACTION_getAppsInfo = 3
  13 TRANSACTION_getAppInfo = 4
  14 TRANSACTION_installApp = 5
  15 TRANSACTION_removeApp = 6
  16 TRANSACTION_launchApp = 7
  17 TRANSACTION_getAppName = 8
  18 TRANSACTION_settingsPutString = 9
  19 TRANSACTION_settingsGetString = 10
  20 TRANSACTION_settingsPutInt = 11
  21 TRANSACTION_getAppName = 12
  22
  23 class IPlatform:
  24     def __init__(self, remote):
  25         self.client = gbinder.Client(remote, INTERFACE)
  26
  27     def getprop(self, arg1, arg2):
  28         request = self.client.new_request()
  29         request.append_string16(arg1)
  30         request.append_string16(arg2)
  31         reply, status = self.client.transact_sync_reply(
  32             TRANSACTION_getprop, request)
  33
  34         if status:
  35             logging.error("Sending reply failed")
  36         else:
  37             reader = reply.init_reader()
  38             status, exception = reader.read_int32()
  39             if exception == 0:
  40                 rep1 = reader.read_string16()
  41                 return rep1
  42             else:
  43                 logging.error("Failed with code: {}".format(exception))
  44
  45         return None
  46
  47     def setprop(self, arg1, arg2):
  48         request = self.client.new_request()
  49         request.append_string16(arg1)
  50         request.append_string16(arg2)
  51         reply, status = self.client.transact_sync_reply(
  52             TRANSACTION_setprop, request)
  53
  54         if status:
  55             logging.error("Sending reply failed")
  56         else:
  57             reader = reply.init_reader()
  58             status, exception = reader.read_int32()
  59             if exception == 0:
  60                 return
  61             else:
  62                 logging.error("Failed with code: {}".format(exception))
  63
  64         return
  65
  66     def getAppsInfo(self):
  67         request = self.client.new_request()
  68         reply, status = self.client.transact_sync_reply(
  69             TRANSACTION_getAppsInfo, request)
  70
  71         if status:
  72             logging.error("Sending reply failed")
  73         else:
  74             reader = reply.init_reader()
  75             apps_list = []
  76             status, exception = reader.read_int32()
  77             if exception == 0:
  78                 status, apps = reader.read_int32()
  79                 for j in range(apps):
  80                     status, has_value = reader.read_int32()
  81                     if has_value == 1:
  82                         appinfo = {
  83                             "name": reader.read_string16(),
  84                             "packageName": reader.read_string16(),
  85                             "action": reader.read_string16(),
  86                             "launchIntent": reader.read_string16(),
  87                             "componentPackageName": reader.read_string16(),
  88                             "componentClassName": reader.read_string16(),
  89                             "categories": []
  90                         }
  91                         status, categories = reader.read_int32()
  92                         for i in range(categories):
  93                             appinfo["categories"].append(reader.read_string16())
  94                         apps_list.append(appinfo)
  95             else:
  96                 logging.error("Failed with code: {}".format(exception))
  97
  98         return apps_list
  99
 100     def getAppInfo(self, arg1):
 101         request = self.client.new_request()
 102         request.append_string16(arg1)
 103         reply, status = self.client.transact_sync_reply(
 104             TRANSACTION_getAppInfo, request)
 105
 106         if status:
 107             logging.error("Sending reply failed")
 108         else:
 109             reader = reply.init_reader()
 110             status, exception = reader.read_int32()
 111             if exception == 0:
 112                 status, has_value = reader.read_int32()
 113                 if has_value == 1:
 114                     appinfo = {
 115                         "name": reader.read_string16(),
 116                         "packageName": reader.read_string16(),
 117                         "action": reader.read_string16(),
 118                         "launchIntent": reader.read_string16(),
 119                         "componentPackageName": reader.read_string16(),
 120                         "componentClassName": reader.read_string16(),
 121                         "categories": []
 122                     }
 123                     status, categories = reader.read_int32()
 124                     for i in range(categories):
 125                         appinfo["categories"].append(reader.read_string16())
 126
 127                     return appinfo
 128             else:
 129                 logging.error("Failed with code: {}".format(exception))
 130
 131         return None
 132
 133     def installApp(self, arg1):
 134         request = self.client.new_request()
 135         request.append_string16(arg1)
 136         reply, status = self.client.transact_sync_reply(
 137             TRANSACTION_installApp, request)
 138
 139         if status:
 140             logging.error("Sending reply failed")
 141         else:
 142             reader = reply.init_reader()
 143             status, exception = reader.read_int32()
 144             if exception == 0:
 145                 status, ret = reader.read_int32()
 146                 return ret
 147             else:
 148                 logging.error("Failed with code: {}".format(exception))
 149
 150         return None
 151
 152     def removeApp(self, arg1):
 153         request = self.client.new_request()
 154         request.append_string16(arg1)
 155         reply, status = self.client.transact_sync_reply(
 156             TRANSACTION_removeApp, request)
 157
 158         if status:
 159             logging.error("Sending reply failed")
 160         else:
 161             reader = reply.init_reader()
 162             status, exception = reader.read_int32()
 163             if exception == 0:
 164                 status, ret = reader.read_int32()
 165                 return ret
 166             else:
 167                 logging.error("Failed with code: {}".format(exception))
 168
 169         return None
 170
 171     def launchApp(self, arg1):
 172         request = self.client.new_request()
 173         request.append_string16(arg1)
 174         reply, status = self.client.transact_sync_reply(
 175             TRANSACTION_launchApp, request)
 176
 177         if status:
 178             logging.error("Sending reply failed")
 179         else:
 180             reader = reply.init_reader()
 181             status, exception = reader.read_int32()
 182             if exception != 0:
 183                 logging.error("Failed with code: {}".format(exception))
 184
 185     def getAppName(self, arg1):
 186         request = self.client.new_request()
 187         request.append_string16(arg1)
 188         reply, status = self.client.transact_sync_reply(
 189             TRANSACTION_getAppName, request)
 190
 191         if status:
 192             logging.error("Sending reply failed")
 193         else:
 194             reader = reply.init_reader()
 195             status, exception = reader.read_int32()
 196             if exception == 0:
 197                 rep1 = reader.read_string16()
 198                 return rep1
 199             else:
 200                 logging.error("Failed with code: {}".format(exception))
 201
 202         return None
 203
 204     def settingsPutString(self, arg1, arg2, arg3):
 205         request = self.client.new_request()
 206         request.append_int32(arg1)
 207         request.append_string16(arg2)
 208         request.append_string16(arg3)
 209         reply, status = self.client.transact_sync_reply(
 210             TRANSACTION_settingsPutString, request)
 211
 212         if status:
 213             logging.error("Sending reply failed")
 214         else:
 215             reader = reply.init_reader()
 216             status, exception = reader.read_int32()
 217             if exception != 0:
 218                 logging.error("Failed with code: {}".format(exception))
 219
 220     def settingsGetString(self, arg1, arg2):
 221         request = self.client.new_request()
 222         request.append_int32(arg1)
 223         request.append_string16(arg2)
 224         reply, status = self.client.transact_sync_reply(
 225             TRANSACTION_settingsGetString, request)
 226
 227         if status:
 228             logging.error("Sending reply failed")
 229         else:
 230             reader = reply.init_reader()
 231             status, exception = reader.read_int32()
 232             if exception == 0:
 233                 rep1 = reader.read_string16()
 234                 return rep1
 235             else:
 236                 logging.error("Failed with code: {}".format(exception))
 237
 238         return None
 239
 240     def settingsPutInt(self, arg1, arg2, arg3):
 241         request = self.client.new_request()
 242         request.append_int32(arg1)
 243         request.append_string16(arg2)
 244         request.append_int32(arg3)
 245         reply, status = self.client.transact_sync_reply(
 246             TRANSACTION_settingsPutInt, request)
 247
 248         if status:
 249             logging.error("Sending reply failed")
 250         else:
 251             reader = reply.init_reader()
 252             status, exception = reader.read_int32()
 253             if exception != 0:
 254                 logging.error("Failed with code: {}".format(exception))
 255
 256     def settingsGetInt(self, arg1, arg2):
 257         request = self.client.new_request()
 258         request.append_int32(arg1)
 259         request.append_string16(arg2)
 260         reply, status = self.client.transact_sync_reply(
 261             TRANSACTION_settingsGetString, request)
 262
 263         if status:
 264             logging.error("Sending reply failed")
 265         else:
 266             reader = reply.init_reader()
 267             status, exception = reader.read_int32()
 268             if exception == 0:
 269                 status, rep1 = reader.read_int32()
 270                 return rep1
 271             else:
 272                 logging.error("Failed with code: {}".format(exception))
 273
 274         return None
 275
 276 def get_service(args):
 277     helpers.drivers.loadBinderNodes(args)
 278     serviceManager = gbinder.ServiceManager("/dev/" + args.BINDER_DRIVER)
 279     tries = 1000
 280
 281     remote, status = serviceManager.get_service_sync(SERVICE_NAME)
 282     while(not remote):
 283         if tries > 0:
 284             logging.warning(
 285                 "Failed to get service {}, trying again...".format(SERVICE_NAME))
 286             time.sleep(1)
 287             remote, status = serviceManager.get_service_sync(SERVICE_NAME)
 288             tries = tries - 1
 289         else:
 290             return None
 291
 292     return IPlatform(remote)