| # python3.4 |
| # Copyright (C) The Android Open Source Project |
| # |
| # Licensed under the Apache License, Version 2.0 (the "License"); you may not |
| # use this file except in compliance with the License. You may obtain a copy of |
| # the License at |
| # |
| # http://www.apache.org/licenses/LICENSE-2.0 |
| # |
| # Unless required by applicable law or agreed to in writing, software |
| # distributed under the License is distributed on an "AS IS" BASIS, WITHOUT |
| # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the |
| # License for the specific language governing permissions and limitations under |
| # the License. |
| |
| """ |
| JSON RPC interface to android scripting engine. |
| |
| Example: |
| a = Android() |
| a.makeToast("poptart") |
| a.close() |
| |
| Also supports serializing data objects (class instances). Register them with the android client object. |
| |
| |
| class Mydata: |
| def __init__(self, value): |
| self.value = value |
| |
| a = Android() |
| a.register(Mydata) |
| |
| data = Mydata(2) |
| a.makeCall(data) |
| a.close() |
| |
| This feature requires support on the SL4A side for the Jackson ObjectMapper. |
| |
| http://jackson.codehaus.org/1.7.3/javadoc/org/codehaus/jackson/map/ObjectMapper.html |
| |
| Where you also need a POJO on the server side. Otherwise this feature cannot be used. |
| """ |
| |
| __author__ = 'Keith Dart <dart@google.com>' |
| __oldauthor__ = 'Damon Kohler <damonkohler@gmail.com>' |
| |
| import os |
| import sys |
| import socket |
| import logging |
| from json.decoder import JSONDecoder |
| from json.encoder import JSONEncoder |
| |
| |
| HOST = os.environ.get('AP_HOST', None) |
| PORT = os.environ.get('AP_PORT', 9999) |
| |
| LAUNCH_CMD=("adb {} shell am start -a com.googlecode.android_scripting.action.LAUNCH_SERVER " |
| "-n com.googlecode.android_scripting/.activity.ScriptingLayerServiceLauncher " |
| "--ei com.googlecode.android_scripting.extra.USE_SERVICE_PORT {}") |
| |
| class SL4AException(Exception): |
| pass |
| |
| class SL4AAPIError(SL4AException): |
| """Raised when remote API reports an error.""" |
| |
| class SL4AProtocolError(SL4AException): |
| """Raised when there is some error in exchanging data with server on device.""" |
| |
| |
| class AndroidJSONDecoder(JSONDecoder): |
| def __init__(self): |
| super().__init__(object_hook=self._decode_object, parse_float=None, parse_int=None, |
| parse_constant=None, strict=True, object_pairs_hook=None) |
| self._regs = {} |
| |
| def _decode_object(self, d): |
| if "@class" in d: |
| cname = d.pop("@class") |
| cls = _load_class(cname) |
| o = cls.__new__(cls) |
| while d: |
| k, v = d.popitem() |
| setattr(o, k, v) |
| return o |
| else: |
| return d |
| |
| def register(self, cls, decoder=None): |
| self._regs[cls] = decoder |
| |
| def decode(self, s): |
| return super().decode(str(s, encoding="utf8")) |
| |
| |
| def _load_class(path): |
| modname, clsname = path.rsplit(".", 1) |
| try: |
| mod = sys.modules[modname] |
| except KeyError: |
| pass |
| __import__(modname) |
| mod = sys.modules[modname] |
| return getattr(mod, clsname) |
| |
| |
| class AndroidJSONEncoder(JSONEncoder): |
| def __init__(self): |
| super().__init__ (skipkeys=False, ensure_ascii=False, |
| check_circular=True, allow_nan=True, sort_keys=False, |
| indent=None, separators=None, default=None) |
| self._regs = {} |
| |
| def default(self, o): |
| try: |
| encoder = self._regs[type(o)] |
| except KeyError: |
| return super().default(o) |
| if encoder is not None: |
| return encoder(o) |
| d = o.__dict__.copy() |
| t = type(o) |
| d["@class"] = "{}.{}".format(t.__module__, t.__name__) |
| return d |
| |
| def encode(self, o): |
| s = super().encode(o) |
| return s.encode("utf8")+b'\n' |
| |
| def register(self, cls, encoder=None): |
| self._regs[cls] = encoder |
| |
| |
| def IDCounter(): |
| i = 0 |
| while True: |
| yield i |
| i += 1 |
| |
| class Android(object): |
| """Client interface to SL4A server running on Android. |
| |
| Supports generic calling to SL4A APIs by getting an API method as an attribute. |
| |
| Example: |
| a = Android() |
| a.makeToast("poptart") |
| """ |
| COUNTER = IDCounter() |
| |
| def __init__(self, cmd='initiate', uid=-1, port=PORT, addr=HOST): |
| self.client = None # prevent close errors on connect failure |
| self.uid = None |
| self._encoder = AndroidJSONEncoder() |
| self._decoder = AndroidJSONDecoder() |
| conn = socket.create_connection((addr, port)) |
| self.client = conn.makefile(mode="brw") |
| handshake = {'cmd':cmd, 'uid':uid} |
| self.client.write(self._encoder.encode(handshake)) |
| self.client.flush() |
| resp = self.client.readline(36384) |
| if not resp: |
| raise SL4AProtocolError("No response from handshake.") |
| result = self._decoder.decode(resp) |
| if result['status']: |
| self.uid = result['uid'] |
| else: |
| self.uid = -1 |
| |
| def close(self): |
| if self.client is not None: |
| c = self.client |
| self.client = None |
| try: |
| # TODO gracefully terminate session when supported on server side. |
| # e.g.: c.write(self._encoder.encode({"cmd":"terminate", "uid":self.uid})) |
| c.close() |
| except (ValueError, OSError): |
| logging.warn("Closing Android interface that was already closed.") |
| |
| def __del__(self): |
| self.close() |
| |
| def register(self, cls, encoder=None, decoder=None): |
| """Register a class object that will support serialization to and |
| from sl4a server. |
| |
| Different encoder and decoder callables may be supplied. If not |
| supplied, generic ones will be used. |
| |
| A factory function can register objects as server side POJOs are developed. |
| """ |
| self._encoder.register(cls, encoder) |
| self._decoder.register(cls, decoder) |
| |
| def _rpc(self, method, *args): |
| apiid = next(Android.COUNTER) |
| data = {'id': apiid, |
| 'method': method, |
| 'params': args} |
| self.client.write(self._encoder.encode(data)) |
| self.client.flush() |
| response = self.client.readline(16384) |
| if not response: |
| raise SL4AProtocolError("No response from server.") |
| result = self._decoder.decode(response) |
| if result['error']: |
| raise SL4AAPIError(result['error']) |
| if result['id'] != apiid: |
| raise SL4AProtocolError("Mismatched API id") |
| return result['result'] |
| |
| def __getattr__(self, name): |
| def rpc_call(*args): |
| return self._rpc(name, *args) |
| return rpc_call |
| |
| |
| def start_forwarding(port, localport=PORT,serial=""): |
| if serial: |
| serial = " -s " + serial |
| os.system("adb {} forward tcp:{} tcp:{}".format(serial,localport, port)) |
| |
| |
| def kill_adb_server(serial=""): |
| if serial: |
| serial = " -s " + serial |
| os.system("adb {} kill-server".format(serial)) |
| |
| |
| def start_adb_server(serial=""): |
| if serial: |
| serial = " -s "+serial |
| os.system("adb {} start-server".format(serial)) |
| |
| |
| def start_sl4a(port=8080,serial=""): |
| if is_sl4a_running(serial): |
| return |
| start_adb_server(serial) |
| if serial: |
| serial = " -s " + serial |
| os.system(LAUNCH_CMD.format(serial,port)) |
| |
| def is_sl4a_running(serial=""): |
| if serial: |
| serial = " -s " + serial |
| status = os.system("adb {} shell ps | grep com.googlecode.android_scripting".format(serial)) |
| return status != 256 |
| |
| def android(argv): |
| import getopt |
| |
| def _usage(): |
| print("""Usage: android [-p <remoteport>] [-l <localport>] [-u <uid>] <apicall>|start [<apiargs>...] |
| Example: android.py -p 8080 makeToast hello""") |
| |
| localport = PORT |
| port = 8080 |
| uid = -1 |
| cmd = "initiate" |
| try: |
| opts, args = getopt.getopt(argv[1:], "l:p:u:", ["localport=", "port=", "uid="]) |
| except getopt.GetoptError: |
| _usage() |
| return |
| for opt, optarg in opts: |
| if opt in ("-p", "--port"): |
| try: |
| port = int(optarg) |
| except ValueError: |
| _usage() |
| return |
| elif opt in ("-u", "--uid"): |
| try: |
| uid = int(optarg) |
| except ValueError: |
| _usage() |
| return |
| cmd = "continue" |
| elif opt in ("-l", "--localport"): |
| try: |
| localport = int(optarg) |
| except ValueError: |
| _usage() |
| return |
| |
| if not args: |
| _usage() |
| return |
| |
| if args[0] == "start": |
| kill_adb_server() |
| start_adb_server() |
| start_sl4a(port) |
| return |
| |
| if cmd == "initiate": |
| start_forwarding(port, localport) |
| |
| a = Android(cmd=cmd, uid=uid, port=localport) |
| print ("UID:", a.uid) |
| rpc = getattr(a, args[0]) |
| rpc(*args[1:]) |
| a.close() |
| |
| |
| # Run as top-level script for handy test utility |
| if __name__ == "__main__": |
| android(sys.argv) |
