void onUserLeft(string channel_id, string user_id) { FunDebug.Log("[Multicast] '{0}' left the '{1}' channel.", user_id, channel_id); if (user_id == sender_) { lock (channel_lock_) { if (tokens_.ContainsKey(channel_id)) { tokens_.Remove(channel_id); } } } if (LeftCallback != null) { LeftCallback(channel_id, user_id); } }
public bool JoinChannel(string channel_id, string token, OnChatMessage handler) { if (!base.JoinChannel(channel_id, token, onReceived)) { return(false); } lock (chat_channel_lock_) { if (chat_channels_.ContainsKey(channel_id)) { FunDebug.LogWarning("Already joined the '{0}' channel.", channel_id); return(false); } chat_channels_.Add(channel_id, handler); } return(true); }
void deleteLocalFiles() { if (delete_file_list_.Count <= 0) { return; } FunDebug.Log("Downloader - Try to delete {0} local files.", delete_file_list_.Count); foreach (string path in delete_file_list_) { if (File.Exists(path)) { File.Delete(path); FunDebug.DebugLog1("'{0}' file deleted.\npath: {1}", Path.GetFileName(path), path); } } delete_file_list_.Clear(); }
/// The 'channel_id' field is mandatory. /// The 'sender' must fill in the message. /// The message shouldn't include join and leave flags. public bool SendToChannel(FunMulticastMessage mcast_msg) { if (mcast_msg == null) { return(false); } FunDebug.Assert(!mcast_msg.join); FunDebug.Assert(!mcast_msg.leave); string channel_id = mcast_msg.channel; if (channel_id == "") { FunDebug.LogWarning("Multicast.SendToChannel - You should set a vaild channel id."); return(false); } lock (channel_lock_) { if (!Connected) { FunDebug.LogWarning("Multicast.SendToChannel - Multicast is not connected.\n" + "If you are trying to send a message in which you were, " + "connect first while preserving the session id you used for join."); return(false); } if (!channels_.ContainsKey(channel_id)) { FunDebug.LogWarning("Multicast.SendToChannel - You are not in the '{0} channel.", channel_id); return(false); } } mcast_msg.sender = sender_; FunMessage fun_msg = FunapiMessage.CreateFunMessage(mcast_msg, MessageType.multicast); session_.SendMessage(kMulticastMsgType, fun_msg); return(true); }
void onError(string channel_id, FunMulticastMessage.ErrorCode code) { FunDebug.LogWarning("[Multicast] error occurred. channel:{0} error:{1}", channel_id, code); if (code == FunMulticastMessage.ErrorCode.EC_CLOSED) { // This error occurs when the server is closed. // If the session is connected, tries to rejoin the channel. if (Connected && InChannel(channel_id)) { string token = null; lock (token_lock_) { if (tokens_.ContainsKey(channel_id)) { token = tokens_[channel_id]; } } requestToJoin(channel_id, token); return; } } if (code != FunMulticastMessage.ErrorCode.EC_ALREADY_JOINED) { lock (channel_lock_) { if (channels_.ContainsKey(channel_id)) { channels_.Remove(channel_id); } } } if (ErrorCallback != null) { ErrorCallback(channel_id, code); } }
void webRequest(string method, string command, string data, Action <object> callback, Action <int, string> user_callback) { if (!isActive && needMatchId(command)) { return; } string url = (needMatchId(command) ? server_url_with_match_id_ : server_url_) + command; FunDebug.Log("FunapiDedicatedServer.webRequest called.\n {0} {1}", method, url); // Request HttpWebRequest web_request = (HttpWebRequest)WebRequest.Create(url); web_request.Method = method; web_request.ContentType = "application/octet-stream"; Request request = new Request(); request.web_request = web_request; request.callback = callback; request.user_callback = user_callback; request.command = command; if (method == "POST") { byte[] bytes = System.Text.Encoding.UTF8.GetBytes(data); ArraySegment <byte> body = new ArraySegment <byte>(bytes); web_request.ContentLength = body.Count; request.body = body; web_request.BeginGetRequestStream(new AsyncCallback(requestStreamCb), request); } else { IAsyncResult result = web_request.BeginGetResponse(new AsyncCallback(responseCb), request); ThreadPool.RegisterWaitForSingleObject( result.AsyncWaitHandle, new WaitOrTimerCallback(TimeoutCallback), request, heartbeat_seconds_ == 0 ? default_timeout_ : (int)(heartbeat_seconds_ / 2f) * 1000, true); } }
public static T GetMessage <T> (FunDedicatedServerRpcMessage msg, MessageType msg_type) { try { object _msg = null; Extensible.TryGetValue(serializer_, MessageTable.GetType(msg_type), msg, (int)msg_type, DataFormat.Default, true, out _msg); FunDebug.Assert(_msg != null, "TryGetValue() failed. Please check the message type."); return((T)_msg); } catch (Exception e) { Type type = MessageTable.GetType(msg_type); FunDebug.LogError("FunapiDSRpcMessage.GetMessage - Failed to decode '{0}' ({1})\n{2}", type, msg_type, e.ToString()); } return(default(T)); }
public static void Compute(MonoBehaviour mono, ref string path, ref DownloadFileInfo file, OnResult on_result) { if (File.Exists(path)) { #if !NO_UNITY mono.StartCoroutine(asyncCompute(path, file, on_result)); #else string path_ = path; DownloadFileInfo file_ = file; mono.StartCoroutine(delegate { asyncCompute(path_, file_, on_result); }); #endif return; } FunDebug.Log("MD5Async.Compute - Can't find a file.\npath: {0}", path); if (on_result != null) { on_result(path, file, false); } }
protected bool encryptMessage(FunapiMessage message, EncryptionType type) { if (type == EncryptionType.kDummyEncryption) { return(true); } if (!encryptors_.ContainsKey(type)) { debug.LogWarning("Encryptor.encryptMessage - Unavailable type: {0}", type); return(false); } Encryptor encryptor = encryptors_[type]; if (encryptor.state != Encryptor.State.kEstablished) { debug.LogWarning("Encryptor.encryptMessage - Can't encrypt '{0}' message. " + "Encryptor state is not established. state: {1}", message.msg_type, encryptor.state); return(false); } if (message.body.Count > 0) { string header = ""; Int64 nSize = encryptor.Encrypt(message.body, message.body, ref header); if (nSize <= 0) { debug.LogWarning("Encryptor.encryptMessage - Failed to encrypt."); return(false); } FunDebug.Assert(nSize == message.body.Count); message.enc_header = header; } return(true); }
public static FunDedicatedServerRpcMessage CreateMessage(object msg, MessageType msg_type) { if (msg is Enum) { msg = (Int32)msg; } try { FunDedicatedServerRpcMessage _msg = new FunDedicatedServerRpcMessage(); Extensible.AppendValue(serializer_, _msg, (int)msg_type, DataFormat.Default, msg); return(_msg); } catch (Exception e) { Type type = MessageTable.GetType(msg_type); FunDebug.LogError("FunapiDSRpcMessage.CreateMessage - Failed to create '{0}' ({1})\n{2}", type, msg_type, e.ToString()); } return(null); }
/// The 'channel_id' field is mandatory. /// The 'sender' must fill in the message. /// The message shouldn't include join and leave flags. public bool SendToChannel(object json_msg) { if (json_msg == null) { return(false); } FunDebug.Assert(!json_helper_.HasField(json_msg, kJoin)); FunDebug.Assert(!json_helper_.HasField(json_msg, kLeave)); string channel_id = json_helper_.GetStringField(json_msg, kChannelId); if (channel_id == "") { FunDebug.LogWarning("Multicast.SendToChannel - You should set a vaild channel id."); return(false); } lock (channel_lock_) { if (!Connected) { FunDebug.LogWarning("Multicast.SendToChannel - Multicast is not connected.\n" + "If you are trying to send a message in which you were, " + "connect first while preserving the session id you used for join."); return(false); } if (!channels_.ContainsKey(channel_id)) { FunDebug.LogWarning("Multicast.SendToChannel - You are not in the '{0} channel.", channel_id); return(false); } } json_helper_.SetStringField(json_msg, kSender, sender_); session_.SendMessage(kMulticastMsgType, json_msg); return(true); }
public void UpdateList(int max_count, int page = 0, string category = "") { if (web_client_ == null || string.IsNullOrEmpty(host_url_)) { FunDebug.LogWarning("Announcement.UpdateList - You must call Init() function first."); onResult(AnnounceResult.kNeedInitialize); return; } // Request a list of announcements. string url = host_url_ + kAnnouncementsUrl + "?count=" + max_count; if (page > 0) { url = url + "&page=" + page; } if (!String.IsNullOrEmpty(category)) { url = url + "&kind=" + Uri.EscapeDataString(category); } web_client_.DownloadDataAsync(new Uri(url)); }
IEnumerator RequestFriendIds(int limit) { oauth_handler_.Clear(); var headers = new Dictionary <string, string>(); headers["Authorization"] = oauth_handler_.GenerateHeader(kFriendsIdsUrl, "GET"); WWW web = new WWW(kFriendsIdsUrl, null, headers); yield return(web); if (!string.IsNullOrEmpty(web.error)) { FunDebug.LogError("Failure in RequestFriendIds: {0}", web.error); OnEventNotify(SNResultCode.kError); } else { Dictionary <string, object> data = Json.Deserialize(web.text) as Dictionary <string, object>; List <object> list = data["ids"] as List <object>; StringBuilder ids = new StringBuilder(); int idx = 0, count = Mathf.Min(list.Count, limit); foreach (object id in list) { ids.AppendFormat("{0},", Convert.ToUInt32(id)); if (++idx >= count) { break; } } if (ids.Length > 0) { StartCoroutine(RequestFriendsInfo(ids.ToString())); } } }
// Connection from the address pool void onConnect(int index) { if (index >= option_.Addrs.Count) { FunDebug.Log("[RPC] Invalid connect index. index:{0} list size:{1}", index, option_.Addrs.Count); return; } cur_index_ = index; FunapiRpcPeer peer = new FunapiRpcPeer(getNextUid(), option_.DisableNagle); KeyValuePair <string, ushort> addr = option_.Addrs[index]; peer.SetAddr(addr.Key, addr.Value); peer.SetEventHandler(onPeerEventBeforeConnect); peer.SetMessageHandler(onPeerMessage); peer_list_.Add(peer); peer.Connect(); }
void OnMyProfileCb(IGraphResult result) { FunDebug.DebugLog1("FacebookConnector.OnMyProfileCb called."); if (result.Error != null) { FunDebug.LogError(result.Error); OnEventNotify(SNResultCode.kError); return; } try { Dictionary <string, object> json = Json.Deserialize(result.RawResult) as Dictionary <string, object>; if (json == null) { FunDebug.LogError("OnMyProfileCb - json is null."); OnEventNotify(SNResultCode.kError); return; } // my profile my_info_.id = json["id"] as string; my_info_.name = json["name"] as string; FunDebug.Log("Facebook id: {0}, name: {1}.", my_info_.id, my_info_.name); // my picture var picture = json["picture"] as Dictionary <string, object>; var data = picture["data"] as Dictionary <string, object>; my_info_.url = data["url"] as string; StartCoroutine(RequestPicture(my_info_)); OnEventNotify(SNResultCode.kMyProfile); } catch (Exception e) { FunDebug.LogError("Failure in OnMyProfileCb: {0}", e.ToString()); } }
public void RequestChannelList() { if (!Connected) { FunDebug.Log("Not connected. First connect before join a multicast channel."); return; } if (encoding_ == FunEncoding.kJson) { Dictionary <string, object> mcast_msg = new Dictionary <string, object>(); mcast_msg[kSender] = sender_; session_.SendMessage(kMulticastMsgType, mcast_msg); } else { FunMulticastMessage mcast_msg = new FunMulticastMessage(); mcast_msg.sender = sender_; FunMessage fun_msg = FunapiMessage.CreateFunMessage(mcast_msg, MessageType.multicast); session_.SendMessage(kMulticastMsgType, fun_msg); } }
public static Encryptor Create(EncryptionType type) { switch (type) { case EncryptionType.kDummyEncryption: return(new Encryptor0()); case EncryptionType.kIFunEngine1Encryption: case EncryptionType.kIFunEngine2Encryption: FunDebug.LogWarning("This plugin is not support '{0}' encryption.", type); return(null); case EncryptionType.kChaCha20Encryption: return(new EncryptorChacha20()); case EncryptionType.kAes128Encryption: return(new EncryptorAes128()); default: FunDebug.LogError("Encryptor.Create - Unknown type: {0}", type); return(null); } }
public bool JoinChannel(string channel_id, string token, ChannelMessage handler) { if (!Connected) { FunDebug.LogWarning("[Multicast] request to join '{0}' channel but session is not connected.", channel_id); return(false); } lock (channel_lock_) { if (channels_.ContainsKey(channel_id)) { FunDebug.LogWarning("[Multicast] request to join '{0}' channel but already joined that channel.", channel_id); return(false); } channels_.Add(channel_id, handler); } requestToJoin(channel_id, token); return(true); }
public void RequestChannelList() { if (!Connected) { FunDebug.LogWarning("[Multicast] request a channel list but the session is not connected."); return; } if (encoding_ == FunEncoding.kJson) { Dictionary <string, object> mcast = new Dictionary <string, object>(); mcast[kSender] = sender_; session_.SendMessage(kMulticastMsgType, mcast, protocol_); } else { FunMulticastMessage mcast = new FunMulticastMessage(); mcast.sender = sender_; FunMessage fun_msg = FunapiMessage.CreateFunMessage(mcast, MessageType.multicast); session_.SendMessage(kMulticastMsgType, fun_msg, protocol_); } }
public bool LeaveChannel(string channel_id) { lock (channel_lock_) { if (channels_.ContainsKey(channel_id)) { channels_.Remove(channel_id); } else { FunDebug.LogWarning("[Multicast] request to leave '{0}' channel but you are not in that channel.", channel_id); return(false); } } if (Connected) { requestToLeave(channel_id); onUserLeft(channel_id, sender_); } return(true); }
protected IEnumerator RequestPictures(List <UserInfo> list) { if (list == null || list.Count <= 0) { yield break; } foreach (UserInfo user in list) { WWW www = new WWW(user.url); yield return(www); if (www.texture != null) { FunDebug.DebugLog1("{0}'s profile picture downloaded.", user.name); user.picture = www.texture; OnPictureNotify(user); } } FunDebug.Log("The all requested profile pictures has been downloaded."); OnEventNotify(SNResultCode.kDownloadCompleted); }
void requestToLeave(string channel_id) { if (encoding_ == FunEncoding.kJson) { Dictionary <string, object> mcast = new Dictionary <string, object>(); mcast[kChannelId] = channel_id; mcast[kSender] = sender_; mcast[kLeave] = true; session_.SendMessage(kMulticastMsgType, mcast, protocol_); } else { FunMulticastMessage mcast = new FunMulticastMessage(); mcast.channel = channel_id; mcast.sender = sender_; mcast.leave = true; FunMessage fun_msg = FunapiMessage.CreateFunMessage(mcast, MessageType.multicast); session_.SendMessage(kMulticastMsgType, fun_msg, protocol_); } FunDebug.Log("[Multicast] requested to leave '{0}' channel.", channel_id); }
public void RequestChannelList() { if (!Connected) { FunDebug.LogWarning("Multicast.RequestChannelList - Multicast is not connected.\n" + "Please connect first before request a channel list."); return; } if (encoding_ == FunEncoding.kJson) { Dictionary <string, object> mcast_msg = new Dictionary <string, object>(); mcast_msg[kSender] = sender_; session_.SendMessage(kMulticastMsgType, mcast_msg); } else { FunMulticastMessage mcast_msg = new FunMulticastMessage(); mcast_msg.sender = sender_; FunMessage fun_msg = FunapiMessage.CreateFunMessage(mcast_msg, MessageType.multicast); session_.SendMessage(kMulticastMsgType, fun_msg); } }
void updateCachedList() { StringBuilder data = new StringBuilder(); data.Append("{ \"list\": [ "); int index = 0; foreach (DownloadFileInfo info in cached_list_) { data.AppendFormat("{{ \"path\":\"{0}\", ", info.path); data.AppendFormat("\"size\":{0}, ", info.size); if (info.hash_front.Length > 0) { data.AppendFormat("\"front\":\"{0}\", ", info.hash_front); } data.AppendFormat("\"hash\":\"{0}\" }}", info.hash); if (++index < cached_list_.Count) { data.Append(", "); } } data.Append(" ] }"); string path = target_path_ + kCachedFileName; FileStream file = File.Open(path, FileMode.Create); StreamWriter stream = new StreamWriter(file); stream.Write(data.ToString()); stream.Flush(); stream.Close(); FunDebug.DebugLog("Updates cached list : {0}", cached_list_.Count); }
public static Encryptor Create(EncryptionType type) { switch (type) { case EncryptionType.kDummyEncryption: return(new Encryptor0()); case EncryptionType.kIFunEngine1Encryption: case EncryptionType.kIFunEngine2Encryption: FunDebug.LogWarning("'{0}' encryption type is not support.", type); return(null); case EncryptionType.kChaCha20Encryption: return(new EncryptorChacha20()); case EncryptionType.kAes128Encryption: return(new EncryptorAes128()); default: FunDebug.LogWarning("Unknown encryptor: {0}", type); FunDebug.Assert(false); return(null); } }
public static void PerformanceTest() { string dict_str = ("N6Qw7OaV4zEcENhIgAAAAAAA2pAu8cEmbIanlFJKKU0jSZMxINMBAABCIJRW" + "+QIAAARAzIeVRcZN0YNRQRiFKgAAAIAAAAAAAAAAAAAAAAAAACRs5KZSRDquS4oAAAAAAAAAAAAAAA" + "EAAAAEAAAACAAAADksIl9tc2d0NTI1ODc4OSwiX21zZ196IjotOTAuOTAwMDAxLTIuNSwibG9va196" + "IjotOTBvb2tfeCI6LTIuNSwibDAzODE0Njk3MjcsImxvb2tfIjotOS4xMDAwMDAzODE0Njk5MDksIm" + "Rpcl96IjotOS4xMDAwMDE1MjU4Nzg5MDksImRpX3giOi0zMy45MDAwMDE1MjUyNDIxOSwiZGlyX3gi" + "Oi0zMy4xOTk5OTY5NDgyNDIxOSwicG9zX3oiOi03Ny4xOTk5OTYwOTI2NTEzNywicG9zX3oxMS4xOT" + "k5OTk4MDkyNjUxM29zX3giOi0xMS4xOTk5ImlkIjo0NDI4OCwicG9zX3hzdF9tb3ZlIn17ImlkIjo0" + "NHBlIjoicmVxdWVzdF9tb3ZlNDgsIl9tc2d0eXBlIjoicmUyMzcwNjA1NDgsIl9tc3oiOi0xNi43OT" + "k5OTkyMzEuNSwibG9va196IjotMTYuImxvb2tfeCI6NjEuNSwibG9feiI6LTMwLjUsImxvb2tfeC0z" + "OS41LCJkaXJfeiI6LTMwNSwiZGlyX3giOi0zOS41LCJwb3NfeiI6NTEuNSwiZGlyXzIzNzA2MDU1LC" + "Jwb3NfeiI6LTU0LjI5OTk5OTIzNzA2MDU0LCJwb3NfeCI6LTU0LjI5OXsiaWQiOjE0NDg0LCJwb3Nf"); byte[] dict_buf = Convert.FromBase64String(dict_str); UIntPtr cdict = ZSTD_createCDict(dict_buf, (UIntPtr)dict_buf.Length, 1); UIntPtr ddict = ZSTD_createDDict(dict_buf, (UIntPtr)dict_buf.Length); string src = "{\"id\":12032,\"pos_x\":31.01,\"pos_z\":45.5293984741," + "\"dir_x\":-14.199799809265137,\"dir_z\":11.899918530274," + "\"look_x\":1.100000381469727,\"look_z\":11.600100381469727," + "\"_msgtype\":\"request_move\"}"; var src_buf = Encoding.UTF8.GetBytes(src); var dst_buf = new byte[(int)ZSTD_compressBound((UIntPtr)src_buf.Length)]; ulong size, size2; long start, end; const int N = 100000; // 알고리즘 반복 시행 횟수 size = 0; size2 = 0; start = DateTime.Now.Ticks / 10000; for (int i = 0; i < N; ++i) { size += (ulong)CompressForFunapi(dst_buf, (UIntPtr)dst_buf.Length, (IntPtr)0, src_buf, (UIntPtr)src_buf.Length, (IntPtr)0, (UIntPtr)0); size2 += (ulong)DecompressForFunapi(src_buf, (UIntPtr)src_buf.Length, (IntPtr)0, dst_buf, (UIntPtr)dst_buf.Length, (IntPtr)0, (UIntPtr)0); } end = DateTime.Now.Ticks / 10000; FunDebug.Log("Zstd (w/o dict) {0} ms, {1} ms/(enc+dec)", end - start, (end - start) * 1.0 / N); FunDebug.Log("String length={0}, compressed={1}", src_buf.Length, size / N); size = 0; size2 = 0; start = DateTime.Now.Ticks / 10000; for (int i = 0; i < N; ++i) { size += (ulong)CompressForFunapi(dst_buf, (UIntPtr)dst_buf.Length, (IntPtr)0, src_buf, (UIntPtr)src_buf.Length, (IntPtr)0, cdict); size2 += (ulong)DecompressForFunapi(src_buf, (UIntPtr)src_buf.Length, (IntPtr)0, dst_buf, (UIntPtr)dst_buf.Length, (IntPtr)0, ddict); } end = DateTime.Now.Ticks / 10000; FunDebug.Log("Zstd (w/ dict) {0} ms, {1} ms/(enc+dec)", end - start, (end - start) * 1.0 / N); FunDebug.Log("String length={0}, compressed={1}", src_buf.Length, size / N); ZSTD_freeCDict(cdict); ZSTD_freeDDict(ddict); size = 0; size2 = 0; dst_buf = new byte[2 * src_buf.Length]; start = DateTime.Now.Ticks / 10000; for (int i = 0; i < N; ++i) { size += (ulong)ZlibCompressForFunapi(dst_buf, (UIntPtr)0, (UIntPtr)dst_buf.Length, src_buf, (UIntPtr)0, (UIntPtr)src_buf.Length); size2 += (ulong)ZlibDecompressForFunapi(src_buf, (UIntPtr)0, (UIntPtr)src_buf.Length, dst_buf, (UIntPtr)0, (UIntPtr)dst_buf.Length); } end = DateTime.Now.Ticks / 10000; FunDebug.Log("Deflate {0} ms, {1} ms/(enc+dec)", end - start, (end - start) * 1.0 / N); FunDebug.Log("String length={0}, compressed={1}", src_buf.Length, size / N); FunapiCompressor comp = new FunapiZstdCompressor(); ArraySegment<byte> intermediate = comp.Compress(new ArraySegment<byte>(src_buf)); ArraySegment<byte> comp_result = comp.Decompress(intermediate, src_buf.Length); var test_target = Encoding.UTF8.GetString(comp_result.Array); FunDebug.Assert(test_target == src); comp = new FunapiDeflateCompressor(); intermediate = comp.Compress(new ArraySegment<byte>(src_buf)); comp_result = comp.Decompress(intermediate, src_buf.Length); test_target = Encoding.UTF8.GetString(comp_result.Array); FunDebug.Assert(test_target == src); }
public static IEnumerator Compute(string path, DownloadFileInfo file, OnResult on_result) { if (!File.Exists(path)) { FunDebug.LogWarning("MD5Async.Compute - Can't find a file.\npath: {0}", path); if (on_result != null) { on_result(path, file, false); } yield break; } MD5 md5 = MD5.Create(); int length, read_bytes; byte[] buffer = new byte[kBlockSize]; string md5hash = ""; FileStream stream = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.Read); if (stream.Length > 0) { if (file.hash_front.Length > 0) { length = (stream.Length < kBlockSize) ? (int)stream.Length : kBlockSize; read_bytes = stream.Read(buffer, 0, length); md5.TransformFinalBlock(buffer, 0, read_bytes); md5hash = FunapiUtils.BytesToHex(md5.Hash); if (md5hash != file.hash_front || length == stream.Length) { stream.Close(); if (on_result != null) { on_result(path, file, md5hash == file.hash_front && md5hash == file.hash); } yield break; } md5.Clear(); md5 = MD5.Create(); stream.Position = 0; yield return(null); } int sleep_count = 0; while (stream.Position < stream.Length) { length = kBlockSize; if (stream.Position + length > stream.Length) { length = (int)(stream.Length - stream.Position); } read_bytes = stream.Read(buffer, 0, length); if (stream.Position < stream.Length) { md5.TransformBlock(buffer, 0, read_bytes, buffer, 0); } else { md5.TransformFinalBlock(buffer, 0, read_bytes); break; } ++sleep_count; if (sleep_count >= kSleepCountMax) { sleep_count = 0; yield return(null); } } } else { md5.TransformFinalBlock(buffer, 0, 0); } stream.Close(); md5hash = FunapiUtils.BytesToHex(md5.Hash); if (on_result != null) { on_result(path, file, md5hash == file.hash); } }
void downloadDataCompleteCb(object sender, DownloadDataCompletedEventArgs ar) { try { if (ar.Error != null) { FunDebug.Log("Exception Error: {0}", ar.Error); onResult(AnnounceResult.kExceptionError); FunDebug.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) { FunDebug.Log("Deserialize json failed. json: {0}", data); onResult(AnnounceResult.kInvalidJson); return; } FunDebug.Assert(json.ContainsKey("list")); List <object> list = json["list"] as List <object>; if (list == null || list.Count <= 0) { if (list == null) { FunDebug.Log("Invalid announcement list. list: {0}", list); } else if (list.Count <= 0) { FunDebug.Log("There are no announcements."); } onResult(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); } } FunDebug.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); FunDebug.Log("Download url: {0}", item.Key); } else { onResult(AnnounceResult.kSucceeded); } } } catch (Exception e) { FunDebug.Log("Failure in downloadDataCompleteCb: {0}", e.ToString()); onResult(AnnounceResult.kExceptionError); } }
public void LogInWithPublish(List <string> perms) { FunDebug.Log("Request facebook login with publish."); FB.LogInWithPublishPermissions(perms, OnLoginCb); }
public void LogInWithRead(List <string> perms) { FunDebug.Log("Request facebook login with read."); FB.LogInWithReadPermissions(perms, OnLoginCb); }