mcs/class/corlib/System.IO/LogcatTextWriter.cs

   1 #if MONODROID
   2
   3 using System;
   4 using System.IO;
   5 using System.Text;
   6 using System.Runtime.CompilerServices;
   7 using System.Runtime.InteropServices;
   8
   9 using Mono;
  10
  11 namespace System.IO {
  12
  13         class LogcatTextWriter : TextWriter {
  14
  15                 const string LibLog = "/system/lib/liblog.so";
  16                 const string LibLog64 = "/system/lib64/liblog.so";
  17
  18                 readonly byte[] appname;
  19
  20                 TextWriter stdout;
  21                 StringBuilder line = new StringBuilder ();
  22
  23                 public LogcatTextWriter (string appname, TextWriter stdout)
  24                 {
  25                         this.appname = Encoding.UTF8.GetBytes (appname + '\0');
  26                         this.stdout = stdout;
  27                 }
  28
  29                 public override Encoding Encoding {
  30                         get {return Encoding.UTF8;}
  31                 }
  32
  33                 public override void Write (string s)
  34                 {
  35                         if (s != null)
  36                                 foreach (char c in s)
  37                                         Write (c);
  38                 }
  39
  40                 public override void Write (char value)
  41                 {
  42                         if (value == '\n')
  43                                 WriteLine ();
  44                         else
  45                                 line.Append (value);
  46                 }
  47
  48                 public override void WriteLine ()
  49                 {
  50                         var o = line.ToString ();
  51                         line.Clear ();
  52
  53                         Log (o);
  54                         stdout.WriteLine (o);
  55                 }
  56
  57                 void Log (string message)
  58                 {
  59                         const int buffer_size = 512;
  60
  61                         unsafe {
  62                                 if (Encoding.UTF8.GetByteCount (message) < buffer_size) {
  63                                         try {
  64                                                 fixed (char *b_message = message) {
  65                                                         byte* buffer = stackalloc byte[buffer_size];
  66                                                         int written = Encoding.UTF8.GetBytes (b_message, message.Length, buffer, buffer_size - 1);
  67                                                         buffer [written] = (byte)'\0';
  68
  69                                                         Log (buffer);
  70                                                 }
  71
  72                                                 return;
  73                                         } catch (ArgumentException) {
  74                                                 /* It might be due to a failure to encode a character, or due to a smaller than necessary buffer. In the
  75                                                 * secode case, we want to fallback to simply allocating on the heap. */
  76                                         }
  77                                 }
  78
  79                                 using (SafeStringMarshal str = new SafeStringMarshal(message)) {
  80                                         Log ((byte*) str.Value);
  81                                 }
  82                         }
  83                 }
  84
  85                 unsafe void Log (byte* b_message)
  86                 {
  87                         fixed (byte *b_appname = appname) {
  88                                 Log (b_appname, 1 << 5 /* G_LOG_LEVEL_MESSAGE */, b_message);
  89                         }
  90                 }
  91
  92                 public static bool IsRunningOnAndroid ()
  93                 {
  94                         return File.Exists (LibLog) || File.Exists (LibLog64);
  95                 }
  96
  97                 [MethodImpl(MethodImplOptions.InternalCall)]
  98                 static unsafe extern void Log (byte *appname, int level, byte *message);
  99         }
 100 }
 101
 102 #endif  // MONODROID