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