public override object Clone(object json_obj)
{
Dictionary <string, object> d = json_obj as Dictionary <string, object>;
DebugUtils.Assert(d != null);
return(new Dictionary <string, object>(d));
}
public override bool HasField(object json_obj, string field_name)
{
Dictionary <string, object> d = json_obj as Dictionary <string, object>;
DebugUtils.Assert(d != null);
return(d.ContainsKey(field_name));
}
public override void RemoveStringField(object json_obj, string field_name)
{
Dictionary <string, object> d = json_obj as Dictionary <string, object>;
DebugUtils.Assert(d != null);
d.Remove(field_name);
}
public override Int64 GetIntegerField(object json_obj, string field_name)
{
Dictionary <string, object> d = json_obj as Dictionary <string, object>;
DebugUtils.Assert(d != null);
return(Convert.ToInt64(d [field_name]));
}
public override string Serialize(object json_obj)
{
Dictionary <string, object> d = json_obj as Dictionary <string, object>;
DebugUtils.Assert(d != null);
return(Json.Serialize(d));
}
public override string GetStringField(object json_obj, string field_name)
{
Dictionary <string, object> d = json_obj as Dictionary <string, object>;
DebugUtils.Assert(d != null);
return(d[field_name] as string);
}
/// <summary>
/// The sender must fill in the mcast_msg.
/// The "channel_id" field is mandatory.
/// And mcas_msg must have join and leave flags set.
/// </summary>
public bool SendToChannel(FunMulticastMessage mcast_msg)
{
DebugUtils.Assert(encoding_ == FunEncoding.kProtobuf);
DebugUtils.Assert(mcast_msg != null);
DebugUtils.Assert(!mcast_msg.join);
DebugUtils.Assert(!mcast_msg.leave);
string channel_id = mcast_msg.channel;
DebugUtils.Assert(channel_id != "");
lock (channel_lock_)
{
if (!Connected)
{
DebugUtils.Log("Not connected. If you are trying to leave a channel in which you were, "
+ "connect first while preserving the session id you used for join.");
return(false);
}
if (!channels_.ContainsKey(channel_id))
{
DebugUtils.Log("You are not in the channel: {0}", channel_id);
return(false);
}
}
FunMessage fun_msg = network_.CreateFunMessage(mcast_msg, MessageType.multicast);
network_.SendMessage(kMulticastMsgType, fun_msg);
return(true);
}
/// <summary>
/// The sender must fill in the mcast_msg.
/// The "channel_id" field is mandatory.
/// And mcas_msg must have join and leave flags set.
/// </summary>
public bool SendToChannel(object json_msg)
{
DebugUtils.Assert(encoding_ == FunEncoding.kJson);
// TODO(dkmoon): Verifies the passed json_msg has required fields.
network_.SendMessage(kMulticastMsgType, json_msg);
return(true);
}
private void DownloadFileCompleteCb(object sender, System.ComponentModel.AsyncCompletedEventArgs ar)
{
try
{
if (ar.Error != null)
{
DebugUtils.Log("Exception Error: {0}", ar.Error);
OnResultCallback(AnnounceResult.kExceptionError);
DebugUtils.Assert(false);
}
else
{
image_list_.RemoveAt(0);
if (image_list_.Count > 0)
{
KeyValuePair <string, string> item = image_list_[0];
web_client_.DownloadFileAsync(new Uri(item.Key), item.Value);
DebugUtils.Log("Download url: {0}", item.Key);
}
else
{
DebugUtils.Log("Download file completed.");
OnResultCallback(AnnounceResult.kSuccess);
}
}
}
catch (Exception e)
{
DebugUtils.Log("Failure in DownloadFileCompleteCb: {0}", e.ToString());
OnResultCallback(AnnounceResult.kExceptionError);
}
}
public override void SetIntegerField(object json_obj, string field_name, Int64 value)
{
Dictionary <string, object> d = json_obj as Dictionary <string, object>;
DebugUtils.Assert(d != null);
d [field_name] = value;
}
public FunapiMulticastClient(FunapiNetwork network, FunEncoding encoding)
{
DebugUtils.Assert(network != null);
network_ = network;
encoding_ = encoding;
network_.RegisterHandlerWithProtocol(kMulticastMsgType, TransportProtocol.kTcp, OnReceived);
}
public override bool Handshake(string in_header, ref string out_header)
{
DebugUtils.Assert(state == State.kHandshaking);
enc_key_ = Convert.ToUInt32(in_header);
dec_key_ = enc_key_;
SetState(State.kEstablished);
return(true);
}
public override Int64 Decrypt(ArraySegment <byte> src, ArraySegment <byte> dst, string in_header)
{
DebugUtils.Assert(state == State.kEstablished);
if (in_header.Length > 0)
{
DebugUtils.LogWarning("Wrong encryptor header.");
return(-1);
}
return(Encrypt(src, dst, false));
}
private void OnReceived(string msg_type, object body)
{
DebugUtils.Assert(msg_type == kMulticastMsgType);
string channel_id = "";
if (encoding_ == FunEncoding.kJson)
{
DebugUtils.Assert(body is Dictionary <string, object>);
Dictionary <string, object> msg = body as Dictionary <string, object>;
channel_id = msg[kChannelId] as string;
lock (channel_lock_)
{
if (!channels_.ContainsKey(channel_id))
{
DebugUtils.Log("You are not in the channel: {0}", channel_id);
return;
}
ChannelReceiveHandler h = channels_[channel_id];
h(channel_id, body);
}
}
else
{
DebugUtils.Assert(body is FunMessage);
FunMessage msg = body as FunMessage;
object obj = network_.GetMessage(msg, MessageType.multicast);
DebugUtils.Assert(obj != null);
FunMulticastMessage mcast_msg = obj as FunMulticastMessage;
channel_id = mcast_msg.channel;
lock (channel_lock_)
{
if (!channels_.ContainsKey(channel_id))
{
DebugUtils.Log("You are not in the channel: {0}", channel_id);
return;
}
ChannelReceiveHandler h = channels_[channel_id];
h(channel_id, mcast_msg);
}
}
}
public override Int64 Encrypt(ArraySegment <byte> src, ArraySegment <byte> dst, ref string out_header)
{
DebugUtils.Assert(state == State.kEstablished);
if (dst.Count < src.Count)
{
return(-1);
}
if (!src.Equals(dst))
{
dst = new ArraySegment <byte>(src.Array, 0, src.Count);
}
return(src.Count);
}
private static Int64 Encrypt(ArraySegment <byte> src, ArraySegment <byte> dst, ref UInt32 key)
{
if (dst.Count < src.Count)
{
return(-1);
}
// update key
key = 8253729 * key + 2396403;
int shift_len = (int)(key & 0x0F);
UInt32 key32 = CircularLeftShift(key, shift_len);
// Encrypted in kBlockSize
for (int i = 0; i < (src.Count / kBlockSize); ++i)
{
UInt32 s = BitConverter.ToUInt32(src.Array, src.Offset + i * kBlockSize);
byte[] d = BitConverter.GetBytes(s ^ key32);
DebugUtils.Assert(d.Length == kBlockSize);
for (int j = 0; j < d.Length; ++j)
{
dst.Array[dst.Offset + i * kBlockSize + j] = d[j];
}
}
byte key8 = 0;
byte[] k = BitConverter.GetBytes(key);
if (BitConverter.IsLittleEndian)
{
key8 = CircularLeftShift(k[0], shift_len);
}
else
{
key8 = CircularLeftShift(k[3], shift_len);
}
// The remaining values are encrypted in units of 1byte
for (int i = 0; i < (src.Count % kBlockSize); ++i)
{
int idx = src.Count - 1 - i;
dst.Array[dst.Offset + idx] = (byte)(src.Array[src.Offset + idx] ^ key8);
}
return(src.Count);
}
private void LoadCachedList()
{
cached_list_.Clear();
string path = target_path_ + kCachedFileName;
if (!File.Exists(path))
{
return;
}
StreamReader stream = File.OpenText(path);
string data = stream.ReadToEnd();
stream.Close();
if (data.Length <= 0)
{
DebugUtils.Log("Failed to get a cached file list.");
DebugUtils.Assert(false);
return;
}
Dictionary <string, object> json = Json.Deserialize(data) as Dictionary <string, object>;
List <object> list = json["list"] as List <object>;
foreach (Dictionary <string, object> node in list)
{
DownloadFileInfo info = new DownloadFileInfo();
info.path = node["path"] as string;
info.size = Convert.ToUInt32(node["size"]);
info.hash = node["hash"] as string;
if (node.ContainsKey("front"))
{
info.hash_front = node["front"] as string;
}
else
{
info.hash_front = "";
}
cached_list_.Add(info);
}
}
public static Encryptor Create(string name)
{
if (name == Encryptor0.kName)
{
return(new Encryptor0());
}
else if (name == Encryptor1.kName)
{
return(new Encryptor1());
}
else if (name == Encryptor2.kName)
{
return(new Encryptor2());
}
DebugUtils.LogWarning("Unknown encryptor: {0}", name);
DebugUtils.Assert(false);
return(null);
}
public static Encryptor Create(EncryptionType type)
{
if (type == EncryptionType.kDummyEncryption)
{
return(new Encryptor0());
}
else if (type == EncryptionType.kIFunEngine1Encryption)
{
return(new Encryptor1());
}
else if (type == EncryptionType.kIFunEngine2Encryption)
{
return(new Encryptor2());
}
DebugUtils.LogWarning("Unknown encryptor: {0}", type);
DebugUtils.Assert(false);
return(null);
}
public override void Init(params object[] param)
{
Debug.Log("TwitterConnector Initialization.");
DebugUtils.Assert(param[0] is string);
DebugUtils.Assert(param[1] is string);
oauth_handler_ = new OAuthHandler(param[0] as string, param[1] as string);
string oauth_token = EncryptedPlayerPrefs.GetString("oauth_token");
string oauth_token_secret = EncryptedPlayerPrefs.GetString("oauth_token_secret");
if (!string.IsNullOrEmpty(oauth_token) && !string.IsNullOrEmpty(oauth_token_secret))
{
oauth_handler_.AddParameter("oauth_token", oauth_token);
oauth_handler_.AddParameter("oauth_token_secret", oauth_token_secret);
my_info_.id = EncryptedPlayerPrefs.GetString("user_id");
my_info_.name = EncryptedPlayerPrefs.GetString("screen_name");
Debug.Log("Already logged in.");
OnEventNotify(SNResultCode.kLoggedIn);
}
}
public virtual bool Handshake(string in_header, ref string out_header)
{
DebugUtils.Assert(false);
return(true);
}
// Callback function for downloaded file.
private void DownloadFileCompleteCb(object sender, System.ComponentModel.AsyncCompletedEventArgs ar)
{
mutex_.WaitOne();
bool failed = false;
try
{
// It can be true when CancelAsync() called in Stop().
if (ar.Cancelled)
{
return;
}
if (ar.Error != null)
{
DebugUtils.Log("Exception Error: {0}", ar.Error);
DebugUtils.Assert(false);
failed = true;
}
else
{
var info = (DownloadFileInfo)ar.UserState;
if (info == null)
{
DebugUtils.Log("DownloadFileInfo object is null.");
failed = true;
}
else
{
string path = target_path_ + info.path;
File.Move(cur_download_path_, path);
++cur_download_count_;
cur_download_size_ += info.size;
download_list_.Remove(info);
cached_list_.Add(info);
DownloadResourceFile();
}
}
}
catch (Exception e)
{
DebugUtils.Log("Failure in DownloadFileCompleteCb: {0}", e.ToString());
failed = true;
}
finally
{
mutex_.ReleaseMutex();
}
if (failed)
{
web_client_.Dispose();
File.Delete(cur_download_path_);
if (retry_download_count_ < kMaxRetryCount)
{
++retry_download_count_;
FunapiManager.instance.StartCoroutine(AsyncDownloadFile());
}
else
{
Stop();
}
}
}
public override Int64 Encrypt(ArraySegment <byte> src, ArraySegment <byte> dst, ref string out_header)
{
DebugUtils.Assert(state == State.kEstablished);
return(Encrypt(src, dst, true));
}
private void DownloadDataCompleteCb(object sender, DownloadDataCompletedEventArgs ar)
{
try
{
if (ar.Error != null)
{
DebugUtils.Log("Exception Error: {0}", ar.Error);
OnResultCallback(AnnounceResult.kExceptionError);
DebugUtils.Assert(false);
}
else
{
// Parse json
string data = Encoding.UTF8.GetString(ar.Result);
Dictionary <string, object> json = Json.Deserialize(data) as Dictionary <string, object>;
if (json == null)
{
DebugUtils.Log("Deserialize json failed. json: {0}", data);
OnResultCallback(AnnounceResult.kInvalidJson);
return;
}
DebugUtils.Assert(json.ContainsKey("list"));
List <object> list = json["list"] as List <object>;
if (list == null || list.Count <= 0)
{
DebugUtils.Log("Invalid announcement list. list: {0}", list);
OnResultCallback(AnnounceResult.kListIsNullOrEmpty);
return;
}
announce_list_.Clear();
foreach (Dictionary <string, object> node in list)
{
announce_list_.Add(node);
// download image
if (node.ContainsKey(kImageUrlKey) && node.ContainsKey(kImageMd5Key))
{
CheckDownloadImage(node[kImageUrlKey] as string, node[kImageMd5Key] as string);
}
}
DebugUtils.Log("Announcement has been updated. total count: {0}", announce_list_.Count);
if (image_list_.Count > 0)
{
// Request a file.
KeyValuePair <string, string> item = image_list_[0];
web_client_.DownloadFileAsync(new Uri(item.Key), item.Value);
DebugUtils.Log("Download url: {0}", item.Key);
}
else
{
OnResultCallback(AnnounceResult.kSuccess);
}
}
}
catch (Exception e)
{
DebugUtils.Log("Failure in DownloadDataCompleteCb: {0}", e.ToString());
OnResultCallback(AnnounceResult.kExceptionError);
}
}
// Callback function for list of files
private void DownloadDataCompleteCb(object sender, DownloadDataCompletedEventArgs ar)
{
mutex_.WaitOne();
bool failed = false;
try
{
if (ar.Error != null)
{
DebugUtils.Log("Exception Error: {0}", ar.Error);
DebugUtils.Assert(false);
failed = true;
}
else
{
// It can be true when CancelAsync() called in Stop().
if (ar.Cancelled)
{
return;
}
// Parse json
string data = Encoding.UTF8.GetString(ar.Result);
Dictionary <string, object> json = Json.Deserialize(data) as Dictionary <string, object>;
//DebugUtils.Log("Json data >> {0}", data);
// Redirect url
if (json.ContainsKey("url"))
{
string url = json["url"] as string;
if (url[url.Length - 1] != '/')
{
url += "/";
}
host_url_ = url;
DebugUtils.Log("Redirect download url: {0}", host_url_);
}
List <object> list = json["data"] as List <object>;
if (list.Count <= 0)
{
DebugUtils.Log("Invalid list data. List count is 0.");
DebugUtils.Assert(false);
failed = true;
}
else
{
download_list_.Clear();
foreach (Dictionary <string, object> node in list)
{
DownloadFileInfo info = new DownloadFileInfo();
info.path = node["path"] as string;
info.size = Convert.ToUInt32(node["size"]);
info.hash = node["md5"] as string;
if (node.ContainsKey("md5_front"))
{
info.hash_front = node["md5_front"] as string;
}
else
{
info.hash_front = "";
}
download_list_.Add(info);
}
// Checks files
manager_.AddEvent(() =>
manager_.StartCoroutine(CheckFileList(download_list_)));
}
}
}
catch (Exception e)
{
DebugUtils.Log("Failure in DownloadDataCompleteCb: {0}", e.ToString());
failed = true;
}
finally
{
mutex_.ReleaseMutex();
}
if (failed)
{
Stop();
}
}
