OpenTween/Twitter.cs

   1 // OpenTween - Client of Twitter
   2 // Copyright (c) 2007-2011 kiri_feather (@kiri_feather) <kiri.feather@gmail.com>
   3 //           (c) 2008-2011 Moz (@syo68k)
   4 //           (c) 2008-2011 takeshik (@takeshik) <http://www.takeshik.org/>
   5 //           (c) 2010-2011 anis774 (@anis774) <http://d.hatena.ne.jp/anis774/>
   6 //           (c) 2010-2011 fantasticswallow (@f_swallow) <http://twitter.com/f_swallow>
   7 //           (c) 2011      Egtra (@egtra) <http://dev.activebasic.com/egtra/>
   8 //           (c) 2013      kim_upsilon (@kim_upsilon) <https://upsilo.net/~upsilon/>
   9 // All rights reserved.
  10 //
  11 // This file is part of OpenTween.
  12 //
  13 // This program is free software; you can redistribute it and/or modify it
  14 // under the terms of the GNU General Public License as published by the Free
  15 // Software Foundation; either version 3 of the License, or (at your option)
  16 // any later version.
  17 //
  18 // This program is distributed in the hope that it will be useful, but
  19 // WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  20 // or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
  21 // for more details.
  22 //
  23 // You should have received a copy of the GNU General Public License along
  24 // with this program. If not, see <http://www.gnu.org/licenses/>, or write to
  25 // the Free Software Foundation, Inc., 51 Franklin Street - Fifth Floor,
  26 // Boston, MA 02110-1301, USA.
  27
  28 using System.Diagnostics;
  29 using System.IO;
  30 using System.Linq;
  31 using System.Net;
  32 using System.Net.Http;
  33 using System.Runtime.CompilerServices;
  34 using System.Runtime.Serialization;
  35 using System.Runtime.Serialization.Json;
  36 using System.Text;
  37 using System.Text.RegularExpressions;
  38 using System.Threading;
  39 using System.Threading.Tasks;
  40 using System.Web;
  41 using System.Xml;
  42 using System.Xml.Linq;
  43 using System.Xml.XPath;
  44 using System;
  45 using System.Reflection;
  46 using System.Collections.Generic;
  47 using System.Drawing;
  48 using System.Windows.Forms;
  49 using OpenTween.Api;
  50 using OpenTween.Api.DataModel;
  51 using OpenTween.Connection;
  52 using OpenTween.Models;
  53 using System.Drawing.Imaging;
  54 using OpenTween.Setting;
  55
  56 namespace OpenTween
  57 {
  58     public class Twitter : IDisposable
  59     {
  60         #region Regexp from twitter-text-js
  61
  62         // The code in this region code block incorporates works covered by
  63         // the following copyright and permission notices:
  64         //
  65         //   Copyright 2011 Twitter, Inc.
  66         //
  67         //   Licensed under the Apache License, Version 2.0 (the "License"); you
  68         //   may not use this work except in compliance with the License. You
  69         //   may obtain a copy of the License in the LICENSE file, or at:
  70         //
  71         //   http://www.apache.org/licenses/LICENSE-2.0
  72         //
  73         //   Unless required by applicable law or agreed to in writing, software
  74         //   distributed under the License is distributed on an "AS IS" BASIS,
  75         //   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
  76         //   implied. See the License for the specific language governing
  77         //   permissions and limitations under the License.
  78
  79         //Hashtag用正規表現
  80         private const string LATIN_ACCENTS = @"\u00c0-\u00d6\u00d8-\u00f6\u00f8-\u00ff\u0100-\u024f\u0253\u0254\u0256\u0257\u0259\u025b\u0263\u0268\u026f\u0272\u0289\u028b\u02bb\u1e00-\u1eff";
  81         private const string NON_LATIN_HASHTAG_CHARS = @"\u0400-\u04ff\u0500-\u0527\u1100-\u11ff\u3130-\u3185\uA960-\uA97F\uAC00-\uD7AF\uD7B0-\uD7FF";
  82         //private const string CJ_HASHTAG_CHARACTERS = @"\u30A1-\u30FA\uFF66-\uFF9F\uFF10-\uFF19\uFF21-\uFF3A\uFF41-\uFF5A\u3041-\u3096\u3400-\u4DBF\u4E00-\u9FFF\u20000-\u2A6DF\u2A700-\u2B73F\u2B740-\u2B81F\u2F800-\u2FA1F";
  83         private const string CJ_HASHTAG_CHARACTERS = @"\u30A1-\u30FA\u30FC\u3005\uFF66-\uFF9F\uFF10-\uFF19\uFF21-\uFF3A\uFF41-\uFF5A\u3041-\u309A\u3400-\u4DBF\p{IsCJKUnifiedIdeographs}";
  84         private const string HASHTAG_BOUNDARY = @"^|$|\s|「|」|。|\.|!";
  85         private const string HASHTAG_ALPHA = "[a-z_" + LATIN_ACCENTS + NON_LATIN_HASHTAG_CHARS + CJ_HASHTAG_CHARACTERS + "]";
  86         private const string HASHTAG_ALPHANUMERIC = "[a-z0-9_" + LATIN_ACCENTS + NON_LATIN_HASHTAG_CHARS + CJ_HASHTAG_CHARACTERS + "]";
  87         private const string HASHTAG_TERMINATOR = "[^a-z0-9_" + LATIN_ACCENTS + NON_LATIN_HASHTAG_CHARS + CJ_HASHTAG_CHARACTERS + "]";
  88         public const string HASHTAG = "(" + HASHTAG_BOUNDARY + ")(#|＃)(" + HASHTAG_ALPHANUMERIC + "*" + HASHTAG_ALPHA + HASHTAG_ALPHANUMERIC + "*)(?=" + HASHTAG_TERMINATOR + "|" + HASHTAG_BOUNDARY + ")";
  89         //URL正規表現
  90         private const string url_valid_preceding_chars = @"(?:[^A-Za-z0-9@＠$#＃\ufffe\ufeff\uffff\u202a-\u202e]|^)";
  91         public const string url_invalid_without_protocol_preceding_chars = @"[-_./]$";
  92         private const string url_invalid_domain_chars = @"\!'#%&'\(\)*\+,\\\-\.\/:;<=>\?@\[\]\^_{|}~\$\u2000-\u200a\u0009-\u000d\u0020\u0085\u00a0\u1680\u180e\u2028\u2029\u202f\u205f\u3000\ufffe\ufeff\uffff\u202a-\u202e";
  93         private const string url_valid_domain_chars = @"[^" + url_invalid_domain_chars + "]";
  94         private const string url_valid_subdomain = @"(?:(?:" + url_valid_domain_chars + @"(?:[_-]|" + url_valid_domain_chars + @")*)?" + url_valid_domain_chars + @"\.)";
  95         private const string url_valid_domain_name = @"(?:(?:" + url_valid_domain_chars + @"(?:-|" + url_valid_domain_chars + @")*)?" + url_valid_domain_chars + @"\.)";
  96         private const string url_valid_GTLD = @"(?:(?:aero|asia|biz|cat|com|coop|edu|gov|info|int|jobs|mil|mobi|museum|name|net|org|pro|tel|travel|xxx)(?=[^0-9a-zA-Z]|$))";
  97         private const string url_valid_CCTLD = @"(?:(?:ac|ad|ae|af|ag|ai|al|am|an|ao|aq|ar|as|at|au|aw|ax|az|ba|bb|bd|be|bf|bg|bh|bi|bj|bm|bn|bo|br|bs|bt|bv|bw|by|bz|ca|cc|cd|cf|cg|ch|ci|ck|cl|cm|cn|co|cr|cs|cu|cv|cx|cy|cz|dd|de|dj|dk|dm|do|dz|ec|ee|eg|eh|er|es|et|eu|fi|fj|fk|fm|fo|fr|ga|gb|gd|ge|gf|gg|gh|gi|gl|gm|gn|gp|gq|gr|gs|gt|gu|gw|gy|hk|hm|hn|hr|ht|hu|id|ie|il|im|in|io|iq|ir|is|it|je|jm|jo|jp|ke|kg|kh|ki|km|kn|kp|kr|kw|ky|kz|la|lb|lc|li|lk|lr|ls|lt|lu|lv|ly|ma|mc|md|me|mg|mh|mk|ml|mm|mn|mo|mp|mq|mr|ms|mt|mu|mv|mw|mx|my|mz|na|nc|ne|nf|ng|ni|nl|no|np|nr|nu|nz|om|pa|pe|pf|pg|ph|pk|pl|pm|pn|pr|ps|pt|pw|py|qa|re|ro|rs|ru|rw|sa|sb|sc|sd|se|sg|sh|si|sj|sk|sl|sm|sn|so|sr|ss|st|su|sv|sy|sz|tc|td|tf|tg|th|tj|tk|tl|tm|tn|to|tp|tr|tt|tv|tw|tz|ua|ug|uk|us|uy|uz|va|vc|ve|vg|vi|vn|vu|wf|ws|ye|yt|za|zm|zw)(?=[^0-9a-zA-Z]|$))";
  98         private const string url_valid_punycode = @"(?:xn--[0-9a-z]+)";
  99         private const string url_valid_domain = @"(?<domain>" + url_valid_subdomain + "*" + url_valid_domain_name + "(?:" + url_valid_GTLD + "|" + url_valid_CCTLD + ")|" + url_valid_punycode + ")";
 100         public const string url_valid_ascii_domain = @"(?:(?:[a-z0-9" + LATIN_ACCENTS + @"]+)\.)+(?:" + url_valid_GTLD + "|" + url_valid_CCTLD + "|" + url_valid_punycode + ")";
 101         public const string url_invalid_short_domain = "^" + url_valid_domain_name + url_valid_CCTLD + "$";
 102         private const string url_valid_port_number = @"[0-9]+";
 103
 104         private const string url_valid_general_path_chars = @"[a-z0-9!*';:=+,.$/%#\[\]\-_~|&" + LATIN_ACCENTS + "]";
 105         private const string url_balance_parens = @"(?:\(" + url_valid_general_path_chars + @"+\))";
 106         private const string url_valid_path_ending_chars = @"(?:[+\-a-z0-9=_#/" + LATIN_ACCENTS + "]|" + url_balance_parens + ")";
 107         private const string pth = "(?:" +
 108             "(?:" +
 109                 url_valid_general_path_chars + "*" +
 110                 "(?:" + url_balance_parens + url_valid_general_path_chars + "*)*" +
 111                 url_valid_path_ending_chars +
 112                 ")|(?:@" + url_valid_general_path_chars + "+/)" +
 113             ")";
 114         private const string qry = @"(?<query>\?[a-z0-9!?*'();:&=+$/%#\[\]\-_.,~|]*[a-z0-9_&=#/])?";
 115         public const string rgUrl = @"(?<before>" + url_valid_preceding_chars + ")" +
 116                                     "(?<url>(?<protocol>https?://)?" +
 117                                     "(?<domain>" + url_valid_domain + ")" +
 118                                     "(?::" + url_valid_port_number + ")?" +
 119                                     "(?<path>/" + pth + "*)?" +
 120                                     qry +
 121                                     ")";
 122
 123         #endregion
 124
 125         /// <summary>
 126         /// Twitter API のステータスページのURL
 127         /// </summary>
 128         public const string ServiceAvailabilityStatusUrl = "https://status.io.watchmouse.com/7617";
 129
 130         /// <summary>
 131         /// ツイートへのパーマリンクURLを判定する正規表現
 132         /// </summary>
 133         public static readonly Regex StatusUrlRegex = new Regex(@"https?://([^.]+\.)?twitter\.com/(#!/)?(?<ScreenName>[a-zA-Z0-9_]+)/status(es)?/(?<StatusId>[0-9]+)(/photo)?", RegexOptions.IgnoreCase);
 134
 135         /// <summary>
 136         /// attachment_url に指定可能な URL を判定する正規表現
 137         /// </summary>
 138         public static readonly Regex AttachmentUrlRegex = new Regex(@"https?://(
 139    twitter\.com/[0-9A-Za-z_]+/status/[0-9]+
 140  | mobile\.twitter\.com/[0-9A-Za-z_]+/status/[0-9]+
 141  | twitter\.com/messages/compose\?recipient_id=[0-9]+(&.+)?
 142 )$", RegexOptions.IgnoreCase | RegexOptions.IgnorePatternWhitespace);
 143
 144         /// <summary>
 145         /// FavstarやaclogなどTwitter関連サービスのパーマリンクURLからステータスIDを抽出する正規表現
 146         /// </summary>
 147         public static readonly Regex ThirdPartyStatusUrlRegex = new Regex(@"https?://(?:[^.]+\.)?(?:
 148   favstar\.fm/users/[a-zA-Z0-9_]+/status/       # Favstar
 149 | favstar\.fm/t/                                # Favstar (short)
 150 | aclog\.koba789\.com/i/                        # aclog
 151 | frtrt\.net/solo_status\.php\?status=          # RtRT
 152 )(?<StatusId>[0-9]+)", RegexOptions.IgnoreCase | RegexOptions.IgnorePatternWhitespace);
 153
 154         /// <summary>
 155         /// DM送信かどうかを判定する正規表現
 156         /// </summary>
 157         public static readonly Regex DMSendTextRegex = new Regex(@"^DM? +(?<id>[a-zA-Z0-9_]+) +(?<body>.*)", RegexOptions.IgnoreCase | RegexOptions.Singleline);
 158
 159         public TwitterApi Api { get; }
 160         public TwitterConfiguration Configuration { get; private set; }
 161         public TwitterTextConfiguration TextConfiguration { get; private set; }
 162
 163         delegate void GetIconImageDelegate(PostClass post);
 164         private readonly object LockObj = new object();
 165         private ISet<long> followerId = new HashSet<long>();
 166         private bool _GetFollowerResult = false;
 167         private long[] noRTId = new long[0];
 168         private bool _GetNoRetweetResult = false;
 169
 170         //プロパティからアクセスされる共通情報
 171         private string _uname;
 172
 173         private bool _readOwnPost;
 174         private List<string> _hashList = new List<string>();
 175
 176         //max_idで古い発言を取得するために保持（lists分は個別タブで管理）
 177         private long minDirectmessage = long.MaxValue;
 178         private long minDirectmessageSent = long.MaxValue;
 179
 180         private long previousStatusId = -1L;
 181
 182         //private FavoriteQueue favQueue;
 183
 184         //private List<PostClass> _deletemessages = new List<PostClass>();
 185
 186         public Twitter() : this(new TwitterApi())
 187         {
 188         }
 189
 190         public Twitter(TwitterApi api)
 191         {
 192             this.Api = api;
 193             this.Configuration = TwitterConfiguration.DefaultConfiguration();
 194             this.TextConfiguration = TwitterTextConfiguration.DefaultConfiguration();
 195         }
 196
 197         public TwitterApiAccessLevel AccessLevel
 198         {
 199             get
 200             {
 201                 return MyCommon.TwitterApiInfo.AccessLevel;
 202             }
 203         }
 204
 205         protected void ResetApiStatus()
 206         {
 207             MyCommon.TwitterApiInfo.Reset();
 208         }
 209
 210         public void ClearAuthInfo()
 211         {
 212             Twitter.AccountState = MyCommon.ACCOUNT_STATE.Invalid;
 213             this.ResetApiStatus();
 214         }
 215
 216         [Obsolete]
 217         public void VerifyCredentials()
 218         {
 219             try
 220             {
 221                 this.VerifyCredentialsAsync().Wait();
 222             }
 223             catch (AggregateException ex) when (ex.InnerException is WebApiException)
 224             {
 225                 throw new WebApiException(ex.InnerException.Message, ex);
 226             }
 227         }
 228
 229         public async Task VerifyCredentialsAsync()
 230         {
 231             var user = await this.Api.AccountVerifyCredentials()
 232                 .ConfigureAwait(false);
 233
 234             this.UpdateUserStats(user);
 235         }
 236
 237         public void Initialize(string token, string tokenSecret, string username, long userId)
 238         {
 239             //OAuth認証
 240             if (string.IsNullOrEmpty(token) || string.IsNullOrEmpty(tokenSecret) || string.IsNullOrEmpty(username))
 241             {
 242                 Twitter.AccountState = MyCommon.ACCOUNT_STATE.Invalid;
 243             }
 244             this.ResetApiStatus();
 245             this.Api.Initialize(token, tokenSecret, userId, username);
 246             _uname = username.ToLowerInvariant();
 247             if (SettingManager.Common.UserstreamStartup) this.ReconnectUserStream();
 248         }
 249
 250         public string PreProcessUrl(string orgData)
 251         {
 252             int posl1;
 253             var posl2 = 0;
 254             //var IDNConveter = new IdnMapping();
 255             var href = "<a href=\"";
 256
 257             while (true)
 258             {
 259                 if (orgData.IndexOf(href, posl2, StringComparison.Ordinal) > -1)
 260                 {
 261                     var urlStr = "";
 262                     // IDN展開
 263                     posl1 = orgData.IndexOf(href, posl2, StringComparison.Ordinal);
 264                     posl1 += href.Length;
 265                     posl2 = orgData.IndexOf("\"", posl1, StringComparison.Ordinal);
 266                     urlStr = orgData.Substring(posl1, posl2 - posl1);
 267
 268                     if (!urlStr.StartsWith("http://", StringComparison.Ordinal)
 269                         && !urlStr.StartsWith("https://", StringComparison.Ordinal)
 270                         && !urlStr.StartsWith("ftp://", StringComparison.Ordinal))
 271                     {
 272                         continue;
 273                     }
 274
 275                     var replacedUrl = MyCommon.IDNEncode(urlStr);
 276                     if (replacedUrl == null) continue;
 277                     if (replacedUrl == urlStr) continue;
 278
 279                     orgData = orgData.Replace("<a href=\"" + urlStr, "<a href=\"" + replacedUrl);
 280                     posl2 = 0;
 281                 }
 282                 else
 283                 {
 284                     break;
 285                 }
 286             }
 287             return orgData;
 288         }
 289
 290         public async Task PostStatus(PostStatusParams param)
 291         {
 292             this.CheckAccountState();
 293
 294             if (Twitter.DMSendTextRegex.IsMatch(param.Text))
 295             {
 296                 await this.SendDirectMessage(param.Text)
 297                     .ConfigureAwait(false);
 298                 return;
 299             }
 300
 301             var response = await this.Api.StatusesUpdate(param.Text, param.InReplyToStatusId, param.MediaIds,
 302                     param.AutoPopulateReplyMetadata, param.ExcludeReplyUserIds, param.AttachmentUrl)
 303                 .ConfigureAwait(false);
 304
 305             var status = await response.LoadJsonAsync()
 306                 .ConfigureAwait(false);
 307
 308             this.UpdateUserStats(status.User);
 309
 310             if (status.Id == this.previousStatusId)
 311                 throw new WebApiException("OK:Delaying?");
 312
 313             this.previousStatusId = status.Id;
 314         }
 315
 316         public Task<long> UploadMedia(IMediaItem item)
 317             => this.UploadMedia(item, SettingManager.Common.AlphaPNGWorkaround);
 318
 319         public async Task<long> UploadMedia(IMediaItem item, bool alphaPNGWorkaround)
 320         {
 321             this.CheckAccountState();
 322
 323             LazyJson<TwitterUploadMediaResult> response;
 324
 325             using (var origImage = item.CreateImage())
 326             {
 327                 if (alphaPNGWorkaround && this.AddAlphaChannelIfNeeded(origImage.Image, out var newImage))
 328                 {
 329                     using (var newMediaItem = new MemoryImageMediaItem(newImage))
 330                     {
 331                         response = await this.Api.MediaUpload(newMediaItem)
 332                             .ConfigureAwait(false);
 333                     }
 334                 }
 335                 else
 336                 {
 337                     response = await this.Api.MediaUpload(item)
 338                         .ConfigureAwait(false);
 339                 }
 340             }
 341
 342             var media = await response.LoadJsonAsync()
 343                 .ConfigureAwait(false);
 344
 345             return media.MediaId;
 346         }
 347
 348         /// <summary>
 349         /// pic.twitter.com アップロード時に JPEG への変換を回避するための加工を行う
 350         /// </summary>
 351         /// <remarks>
 352         /// pic.twitter.com へのアップロード時に、アルファチャンネルを持たない PNG 画像が
 353         /// JPEG 形式に変換され画質が低下する問題を回避します。
 354         /// PNG 以外の画像や、すでにアルファチャンネルを持つ PNG 画像に対しては何もしません。
 355         /// </remarks>
 356         /// <returns>加工が行われた場合は true、そうでない場合は false</returns>
 357         private bool AddAlphaChannelIfNeeded(Image origImage, out MemoryImage newImage)
 358         {
 359             newImage = null;
 360
 361             // PNG 画像以外に対しては何もしない
 362             if (origImage.RawFormat.Guid != ImageFormat.Png.Guid)
 363                 return false;
 364
 365             using (var bitmap = new Bitmap(origImage))
 366             {
 367                 // アルファ値が 255 以外のピクセルが含まれていた場合は何もしない
 368                 foreach (var x in Enumerable.Range(0, bitmap.Width))
 369                 {
 370                     foreach (var y in Enumerable.Range(0, bitmap.Height))
 371                     {
 372                         if (bitmap.GetPixel(x, y).A != 255)
 373                             return false;
 374                     }
 375                 }
 376
 377                 // 左上の 1px だけアルファ値を 254 にする
 378                 var pixel = bitmap.GetPixel(0, 0);
 379                 var newPixel = Color.FromArgb(pixel.A - 1, pixel.R, pixel.G, pixel.B);
 380                 bitmap.SetPixel(0, 0, newPixel);
 381
 382                 // MemoryImage 作成時に画像はコピーされるため、この後 bitmap は破棄しても問題ない
 383                 newImage = MemoryImage.CopyFromImage(bitmap);
 384
 385                 return true;
 386             }
 387         }
 388
 389         public async Task SendDirectMessage(string postStr)
 390         {
 391             this.CheckAccountState();
 392             this.CheckAccessLevel(TwitterApiAccessLevel.ReadWriteAndDirectMessage);
 393
 394             var mc = Twitter.DMSendTextRegex.Match(postStr);
 395
 396             var response = await this.Api.DirectMessagesNew(mc.Groups["body"].Value, mc.Groups["id"].Value)
 397                 .ConfigureAwait(false);
 398
 399             var dm = await response.LoadJsonAsync()
 400                 .ConfigureAwait(false);
 401
 402             this.UpdateUserStats(dm.Sender);
 403         }
 404
 405         public async Task PostRetweet(long id, bool read)
 406         {
 407             this.CheckAccountState();
 408
 409             //データ部分の生成
 410             var post = TabInformations.GetInstance()[id];
 411             if (post == null)
 412                 throw new WebApiException("Err:Target isn't found.");
 413
 414             var target = post.RetweetedId ?? id;  //再RTの場合は元発言をRT
 415
 416             var response = await this.Api.StatusesRetweet(target)
 417                 .ConfigureAwait(false);
 418
 419             var status = await response.LoadJsonAsync()
 420                 .ConfigureAwait(false);
 421
 422             //二重取得回避
 423             lock (LockObj)
 424             {
 425                 if (TabInformations.GetInstance().ContainsKey(status.Id))
 426                     return;
 427             }
 428
 429             //Retweet判定
 430             if (status.RetweetedStatus == null)
 431                 throw new WebApiException("Invalid Json!");
 432
 433             //ReTweetしたものをTLに追加
 434             post = CreatePostsFromStatusData(status);
 435
 436             //ユーザー情報
 437             post.IsMe = true;
 438
 439             post.IsRead = read;
 440             post.IsOwl = false;
 441             if (_readOwnPost) post.IsRead = true;
 442             post.IsDm = false;
 443
 444             TabInformations.GetInstance().AddPost(post);
 445         }
 446
 447         public string Username
 448             => this.Api.CurrentScreenName;
 449
 450         public long UserId
 451             => this.Api.CurrentUserId;
 452
 453         private static MyCommon.ACCOUNT_STATE _accountState = MyCommon.ACCOUNT_STATE.Valid;
 454         public static MyCommon.ACCOUNT_STATE AccountState
 455         {
 456             get
 457             {
 458                 return _accountState;
 459             }
 460             set
 461             {
 462                 _accountState = value;
 463             }
 464         }
 465
 466         public bool RestrictFavCheck { get; set; }
 467
 468         public bool ReadOwnPost
 469         {
 470             get
 471             {
 472                 return _readOwnPost;
 473             }
 474             set
 475             {
 476                 _readOwnPost = value;
 477             }
 478         }
 479
 480         public int FollowersCount { get; private set; }
 481         public int FriendsCount { get; private set; }
 482         public int StatusesCount { get; private set; }
 483         public string Location { get; private set; } = "";
 484         public string Bio { get; private set; } = "";
 485
 486         /// <summary>ユーザーのフォロワー数などの情報を更新します</summary>
 487         private void UpdateUserStats(TwitterUser self)
 488         {
 489             this.FollowersCount = self.FollowersCount;
 490             this.FriendsCount = self.FriendsCount;
 491             this.StatusesCount = self.StatusesCount;
 492             this.Location = self.Location;
 493             this.Bio = self.Description;
 494         }
 495
 496         /// <summary>
 497         /// 渡された取得件数がWORKERTYPEに応じた取得可能範囲に収まっているか検証する
 498         /// </summary>
 499         public static bool VerifyApiResultCount(MyCommon.WORKERTYPE type, int count)
 500         {
 501             return count >= 20 && count <= GetMaxApiResultCount(type);
 502         }
 503
 504         /// <summary>
 505         /// 渡された取得件数が更新時の取得可能範囲に収まっているか検証する
 506         /// </summary>
 507         public static bool VerifyMoreApiResultCount(int count)
 508         {
 509             return count >= 20 && count <= 200;
 510         }
 511
 512         /// <summary>
 513         /// 渡された取得件数が起動時の取得可能範囲に収まっているか検証する
 514         /// </summary>
 515         public static bool VerifyFirstApiResultCount(int count)
 516         {
 517             return count >= 20 && count <= 200;
 518         }
 519
 520         /// <summary>
 521         /// WORKERTYPEに応じた取得可能な最大件数を取得する
 522         /// </summary>
 523         public static int GetMaxApiResultCount(MyCommon.WORKERTYPE type)
 524         {
 525             // 参照: REST APIs - 各endpointのcountパラメータ
 526             // https://dev.twitter.com/rest/public
 527             switch (type)
 528             {
 529                 case MyCommon.WORKERTYPE.Timeline:
 530                 case MyCommon.WORKERTYPE.Reply:
 531                 case MyCommon.WORKERTYPE.UserTimeline:
 532                 case MyCommon.WORKERTYPE.Favorites:
 533                 case MyCommon.WORKERTYPE.DirectMessegeRcv:
 534                 case MyCommon.WORKERTYPE.DirectMessegeSnt:
 535                 case MyCommon.WORKERTYPE.List:  // 不明
 536                     return 200;
 537
 538                 case MyCommon.WORKERTYPE.PublicSearch:
 539                     return 100;
 540
 541                 default:
 542                     throw new InvalidOperationException("Invalid type: " + type);
 543             }
 544         }
 545
 546         /// <summary>
 547         /// WORKERTYPEに応じた取得件数を取得する
 548         /// </summary>
 549         public static int GetApiResultCount(MyCommon.WORKERTYPE type, bool more, bool startup)
 550         {
 551             if (type == MyCommon.WORKERTYPE.DirectMessegeRcv ||
 552                 type == MyCommon.WORKERTYPE.DirectMessegeSnt)
 553             {
 554                 return 20;
 555             }
 556
 557             if (SettingManager.Common.UseAdditionalCount)
 558             {
 559                 switch (type)
 560                 {
 561                     case MyCommon.WORKERTYPE.Favorites:
 562                         if (SettingManager.Common.FavoritesCountApi != 0)
 563                             return SettingManager.Common.FavoritesCountApi;
 564                         break;
 565                     case MyCommon.WORKERTYPE.List:
 566                         if (SettingManager.Common.ListCountApi != 0)
 567                             return SettingManager.Common.ListCountApi;
 568                         break;
 569                     case MyCommon.WORKERTYPE.PublicSearch:
 570                         if (SettingManager.Common.SearchCountApi != 0)
 571                             return SettingManager.Common.SearchCountApi;
 572                         break;
 573                     case MyCommon.WORKERTYPE.UserTimeline:
 574                         if (SettingManager.Common.UserTimelineCountApi != 0)
 575                             return SettingManager.Common.UserTimelineCountApi;
 576                         break;
 577                 }
 578                 if (more && SettingManager.Common.MoreCountApi != 0)
 579                 {
 580                     return Math.Min(SettingManager.Common.MoreCountApi, GetMaxApiResultCount(type));
 581                 }
 582                 if (startup && SettingManager.Common.FirstCountApi != 0 && type != MyCommon.WORKERTYPE.Reply)
 583                 {
 584                     return Math.Min(SettingManager.Common.FirstCountApi, GetMaxApiResultCount(type));
 585                 }
 586             }
 587
 588             // 上記に当てはまらない場合の共通処理
 589             var count = SettingManager.Common.CountApi;
 590
 591             if (type == MyCommon.WORKERTYPE.Reply)
 592                 count = SettingManager.Common.CountApiReply;
 593
 594             return Math.Min(count, GetMaxApiResultCount(type));
 595         }
 596
 597         public async Task GetHomeTimelineApi(bool read, HomeTabModel tab, bool more, bool startup)
 598         {
 599             this.CheckAccountState();
 600
 601             var count = GetApiResultCount(MyCommon.WORKERTYPE.Timeline, more, startup);
 602
 603             TwitterStatus[] statuses;
 604             if (more)
 605             {
 606                 statuses = await this.Api.StatusesHomeTimeline(count, maxId: tab.OldestId)
 607                     .ConfigureAwait(false);
 608             }
 609             else
 610             {
 611                 statuses = await this.Api.StatusesHomeTimeline(count)
 612                     .ConfigureAwait(false);
 613             }
 614
 615             var minimumId = this.CreatePostsFromJson(statuses, MyCommon.WORKERTYPE.Timeline, tab, read);
 616             if (minimumId != null)
 617                 tab.OldestId = minimumId.Value;
 618         }
 619
 620         public async Task GetMentionsTimelineApi(bool read, MentionsTabModel tab, bool more, bool startup)
 621         {
 622             this.CheckAccountState();
 623
 624             var count = GetApiResultCount(MyCommon.WORKERTYPE.Reply, more, startup);
 625
 626             TwitterStatus[] statuses;
 627             if (more)
 628             {
 629                 statuses = await this.Api.StatusesMentionsTimeline(count, maxId: tab.OldestId)
 630                     .ConfigureAwait(false);
 631             }
 632             else
 633             {
 634                 statuses = await this.Api.StatusesMentionsTimeline(count)
 635                     .ConfigureAwait(false);
 636             }
 637
 638             var minimumId = this.CreatePostsFromJson(statuses, MyCommon.WORKERTYPE.Reply, tab, read);
 639             if (minimumId != null)
 640                 tab.OldestId = minimumId.Value;
 641         }
 642
 643         public async Task GetUserTimelineApi(bool read, string userName, UserTimelineTabModel tab, bool more)
 644         {
 645             this.CheckAccountState();
 646
 647             var count = GetApiResultCount(MyCommon.WORKERTYPE.UserTimeline, more, false);
 648
 649             TwitterStatus[] statuses;
 650             if (string.IsNullOrEmpty(userName))
 651             {
 652                 var target = tab.ScreenName;
 653                 if (string.IsNullOrEmpty(target)) return;
 654                 userName = target;
 655                 statuses = await this.Api.StatusesUserTimeline(userName, count)
 656                     .ConfigureAwait(false);
 657             }
 658             else
 659             {
 660                 if (more)
 661                 {
 662                     statuses = await this.Api.StatusesUserTimeline(userName, count, maxId: tab.OldestId)
 663                         .ConfigureAwait(false);
 664                 }
 665                 else
 666                 {
 667                     statuses = await this.Api.StatusesUserTimeline(userName, count)
 668                         .ConfigureAwait(false);
 669                 }
 670             }
 671
 672             var minimumId = CreatePostsFromJson(statuses, MyCommon.WORKERTYPE.UserTimeline, tab, read);
 673
 674             if (minimumId != null)
 675                 tab.OldestId = minimumId.Value;
 676         }
 677
 678         public async Task<PostClass> GetStatusApi(bool read, long id)
 679         {
 680             this.CheckAccountState();
 681
 682             var status = await this.Api.StatusesShow(id)
 683                 .ConfigureAwait(false);
 684
 685             var item = CreatePostsFromStatusData(status);
 686
 687             item.IsRead = read;
 688             if (item.IsMe && !read && _readOwnPost) item.IsRead = true;
 689
 690             return item;
 691         }
 692
 693         public async Task GetStatusApi(bool read, long id, TabModel tab)
 694         {
 695             var post = await this.GetStatusApi(read, id)
 696                 .ConfigureAwait(false);
 697
 698             //非同期アイコン取得＆StatusDictionaryに追加
 699             if (tab != null && tab.IsInnerStorageTabType)
 700                 tab.AddPostQueue(post);
 701             else
 702                 TabInformations.GetInstance().AddPost(post);
 703         }
 704
 705         private PostClass CreatePostsFromStatusData(TwitterStatus status)
 706         {
 707             return CreatePostsFromStatusData(status, false);
 708         }
 709
 710         private PostClass CreatePostsFromStatusData(TwitterStatus status, bool favTweet)
 711         {
 712             var post = new PostClass();
 713             TwitterEntities entities;
 714             string sourceHtml;
 715
 716             post.StatusId = status.Id;
 717             if (status.RetweetedStatus != null)
 718             {
 719                 var retweeted = status.RetweetedStatus;
 720
 721                 post.CreatedAt = new DateTimeUtc(MyCommon.DateTimeParse(retweeted.CreatedAt).ToUniversalTime());
 722
 723                 //Id
 724                 post.RetweetedId = retweeted.Id;
 725                 //本文
 726                 post.TextFromApi = retweeted.FullText;
 727                 entities = retweeted.MergedEntities;
 728                 sourceHtml = retweeted.Source;
 729                 //Reply先
 730                 post.InReplyToStatusId = retweeted.InReplyToStatusId;
 731                 post.InReplyToUser = retweeted.InReplyToScreenName;
 732                 post.InReplyToUserId = status.InReplyToUserId;
 733
 734                 if (favTweet)
 735                 {
 736                     post.IsFav = true;
 737                 }
 738                 else
 739                 {
 740                     //幻覚fav対策
 741                     var tc = TabInformations.GetInstance().GetTabByType(MyCommon.TabUsageType.Favorites);
 742                     post.IsFav = tc.Contains(retweeted.Id);
 743                 }
 744
 745                 if (retweeted.Coordinates != null)
 746                     post.PostGeo = new PostClass.StatusGeo(retweeted.Coordinates.Coordinates[0], retweeted.Coordinates.Coordinates[1]);
 747
 748                 //以下、ユーザー情報
 749                 var user = retweeted.User;
 750                 if (user != null)
 751                 {
 752                     post.UserId = user.Id;
 753                     post.ScreenName = user.ScreenName;
 754                     post.Nickname = user.Name.Trim();
 755                     post.ImageUrl = user.ProfileImageUrlHttps;
 756                     post.IsProtect = user.Protected;
 757                 }
 758                 else
 759                 {
 760                     post.UserId = 0L;
 761                     post.ScreenName = "?????";
 762                     post.Nickname = "Unknown User";
 763                 }
 764
 765                 //Retweetした人
 766                 if (status.User != null)
 767                 {
 768                     post.RetweetedBy = status.User.ScreenName;
 769                     post.RetweetedByUserId = status.User.Id;
 770                     post.IsMe = post.RetweetedBy.ToLowerInvariant().Equals(_uname);
 771                 }
 772                 else
 773                 {
 774                     post.RetweetedBy = "?????";
 775                     post.RetweetedByUserId = 0L;
 776                 }
 777             }
 778             else
 779             {
 780                 post.CreatedAt = new DateTimeUtc(MyCommon.DateTimeParse(status.CreatedAt).ToUniversalTime());
 781                 //本文
 782                 post.TextFromApi = status.FullText;
 783                 entities = status.MergedEntities;
 784                 sourceHtml = status.Source;
 785                 post.InReplyToStatusId = status.InReplyToStatusId;
 786                 post.InReplyToUser = status.InReplyToScreenName;
 787                 post.InReplyToUserId = status.InReplyToUserId;
 788
 789                 if (favTweet)
 790                 {
 791                     post.IsFav = true;
 792                 }
 793                 else
 794                 {
 795                     //幻覚fav対策
 796                     var tc = TabInformations.GetInstance().GetTabByType(MyCommon.TabUsageType.Favorites);
 797                     post.IsFav = tc.Contains(post.StatusId) && TabInformations.GetInstance()[post.StatusId].IsFav;
 798                 }
 799
 800                 if (status.Coordinates != null)
 801                     post.PostGeo = new PostClass.StatusGeo(status.Coordinates.Coordinates[0], status.Coordinates.Coordinates[1]);
 802
 803                 //以下、ユーザー情報
 804                 var user = status.User;
 805                 if (user != null)
 806                 {
 807                     post.UserId = user.Id;
 808                     post.ScreenName = user.ScreenName;
 809                     post.Nickname = user.Name.Trim();
 810                     post.ImageUrl = user.ProfileImageUrlHttps;
 811                     post.IsProtect = user.Protected;
 812                     post.IsMe = post.ScreenName.ToLowerInvariant().Equals(_uname);
 813                 }
 814                 else
 815                 {
 816                     post.UserId = 0L;
 817                     post.ScreenName = "?????";
 818                     post.Nickname = "Unknown User";
 819                 }
 820             }
 821             //HTMLに整形
 822             string textFromApi = post.TextFromApi;
 823             post.Text = CreateHtmlAnchor(textFromApi, post.ReplyToList, entities, post.Media);
 824             post.TextFromApi = textFromApi;
 825             post.TextFromApi = this.ReplaceTextFromApi(post.TextFromApi, entities);
 826             post.TextFromApi = WebUtility.HtmlDecode(post.TextFromApi);
 827             post.TextFromApi = post.TextFromApi.Replace("<3", "\u2661");
 828             post.AccessibleText = this.CreateAccessibleText(textFromApi, entities, (status.RetweetedStatus ?? status).QuotedStatus);
 829             post.AccessibleText = WebUtility.HtmlDecode(post.AccessibleText);
 830             post.AccessibleText = post.AccessibleText.Replace("<3", "\u2661");
 831
 832             post.QuoteStatusIds = GetQuoteTweetStatusIds(entities)
 833                 .Where(x => x != post.StatusId && x != post.RetweetedId)
 834                 .Distinct().ToArray();
 835
 836             post.ExpandedUrls = entities.OfType<TwitterEntityUrl>()
 837                 .Select(x => new PostClass.ExpandedUrlInfo(x.Url, x.ExpandedUrl))
 838                 .ToArray();
 839
 840             // メモリ使用量削減 (同一のテキストであれば同一の string インスタンスを参照させる)
 841             if (post.Text == post.TextFromApi)
 842                 post.Text = post.TextFromApi;
 843             if (post.AccessibleText == post.TextFromApi)
 844                 post.AccessibleText = post.TextFromApi;
 845
 846             // 他の発言と重複しやすい (共通化できる) 文字列は string.Intern を通す
 847             post.ScreenName = string.Intern(post.ScreenName);
 848             post.Nickname = string.Intern(post.Nickname);
 849             post.ImageUrl = string.Intern(post.ImageUrl);
 850             post.RetweetedBy = post.RetweetedBy != null ? string.Intern(post.RetweetedBy) : null;
 851
 852             //Source整形
 853             var (sourceText, sourceUri) = ParseSource(sourceHtml);
 854             post.Source = string.Intern(sourceText);
 855             post.SourceUri = sourceUri;
 856
 857             post.IsReply = post.RetweetedId == null && post.ReplyToList.Any(x => x.Item1 == this.UserId);
 858             post.IsExcludeReply = false;
 859
 860             if (post.IsMe)
 861             {
 862                 post.IsOwl = false;
 863             }
 864             else
 865             {
 866                 if (followerId.Count > 0) post.IsOwl = !followerId.Contains(post.UserId);
 867             }
 868
 869             post.IsDm = false;
 870             return post;
 871         }
 872
 873         /// <summary>
 874         /// ツイートに含まれる引用ツイートのURLからステータスIDを抽出
 875         /// </summary>
 876         public static IEnumerable<long> GetQuoteTweetStatusIds(IEnumerable<TwitterEntity> entities)
 877         {
 878             var urls = entities.OfType<TwitterEntityUrl>().Select(x => x.ExpandedUrl);
 879
 880             return GetQuoteTweetStatusIds(urls);
 881         }
 882
 883         public static IEnumerable<long> GetQuoteTweetStatusIds(IEnumerable<string> urls)
 884         {
 885             foreach (var url in urls)
 886             {
 887                 var match = Twitter.StatusUrlRegex.Match(url);
 888                 if (match.Success)
 889                 {
 890                     if (long.TryParse(match.Groups["StatusId"].Value, out var statusId))
 891                         yield return statusId;
 892                 }
 893             }
 894         }
 895
 896         private long? CreatePostsFromJson(TwitterStatus[] items, MyCommon.WORKERTYPE gType, TabModel tab, bool read)
 897         {
 898             long? minimumId = null;
 899
 900             foreach (var status in items)
 901             {
 902                 if (minimumId == null || minimumId.Value > status.Id)
 903                     minimumId = status.Id;
 904
 905                 //二重取得回避
 906                 lock (LockObj)
 907                 {
 908                     if (tab == null)
 909                     {
 910                         if (TabInformations.GetInstance().ContainsKey(status.Id)) continue;
 911                     }
 912                     else
 913                     {
 914                         if (tab.Contains(status.Id)) continue;
 915                     }
 916                 }
 917
 918                 //RT禁止ユーザーによるもの
 919                 if (gType != MyCommon.WORKERTYPE.UserTimeline &&
 920                     status.RetweetedStatus != null && this.noRTId.Contains(status.User.Id)) continue;
 921
 922                 var post = CreatePostsFromStatusData(status);
 923
 924                 post.IsRead = read;
 925                 if (post.IsMe && !read && _readOwnPost) post.IsRead = true;
 926
 927                 if (tab != null && tab.IsInnerStorageTabType)
 928                     tab.AddPostQueue(post);
 929                 else
 930                     TabInformations.GetInstance().AddPost(post);
 931             }
 932
 933             return minimumId;
 934         }
 935
 936         private long? CreatePostsFromSearchJson(TwitterSearchResult items, PublicSearchTabModel tab, bool read, bool more)
 937         {
 938             long? minimumId = null;
 939
 940             foreach (var status in items.Statuses)
 941             {
 942                 if (minimumId == null || minimumId.Value > status.Id)
 943                     minimumId = status.Id;
 944
 945                 if (!more && status.Id > tab.SinceId) tab.SinceId = status.Id;
 946                 //二重取得回避
 947                 lock (LockObj)
 948                 {
 949                     if (tab.Contains(status.Id)) continue;
 950                 }
 951
 952                 var post = CreatePostsFromStatusData(status);
 953
 954                 post.IsRead = read;
 955                 if ((post.IsMe && !read) && this._readOwnPost) post.IsRead = true;
 956
 957                 tab.AddPostQueue(post);
 958             }
 959
 960             return minimumId;
 961         }
 962
 963         private long? CreateFavoritePostsFromJson(TwitterStatus[] items, bool read)
 964         {
 965             var favTab = TabInformations.GetInstance().GetTabByType(MyCommon.TabUsageType.Favorites);
 966             long? minimumId = null;
 967
 968             foreach (var status in items)
 969             {
 970                 if (minimumId == null || minimumId.Value > status.Id)
 971                     minimumId = status.Id;
 972
 973                 //二重取得回避
 974                 lock (LockObj)
 975                 {
 976                     if (favTab.Contains(status.Id)) continue;
 977                 }
 978
 979                 var post = CreatePostsFromStatusData(status, true);
 980
 981                 post.IsRead = read;
 982
 983                 TabInformations.GetInstance().AddPost(post);
 984             }
 985
 986             return minimumId;
 987         }
 988
 989         public async Task GetListStatus(bool read, ListTimelineTabModel tab, bool more, bool startup)
 990         {
 991             var count = GetApiResultCount(MyCommon.WORKERTYPE.List, more, startup);
 992
 993             TwitterStatus[] statuses;
 994             if (more)
 995             {
 996                 statuses = await this.Api.ListsStatuses(tab.ListInfo.Id, count, maxId: tab.OldestId, includeRTs: SettingManager.Common.IsListsIncludeRts)
 997                     .ConfigureAwait(false);
 998             }
 999             else
1000             {
1001                 statuses = await this.Api.ListsStatuses(tab.ListInfo.Id, count, includeRTs: SettingManager.Common.IsListsIncludeRts)
1002                     .ConfigureAwait(false);
1003             }
1004
1005             var minimumId = CreatePostsFromJson(statuses, MyCommon.WORKERTYPE.List, tab, read);
1006
1007             if (minimumId != null)
1008                 tab.OldestId = minimumId.Value;
1009         }
1010
1011         /// <summary>
1012         /// startStatusId からリプライ先の発言を辿る。発言は posts 以外からは検索しない。
1013         /// </summary>
1014         /// <returns>posts の中から検索されたリプライチェインの末端</returns>
1015         internal static PostClass FindTopOfReplyChain(IDictionary<Int64, PostClass> posts, Int64 startStatusId)
1016         {
1017             if (!posts.ContainsKey(startStatusId))
1018                 throw new ArgumentException("startStatusId (" + startStatusId + ") が posts の中から見つかりませんでした。", nameof(startStatusId));
1019
1020             var nextPost = posts[startStatusId];
1021             while (nextPost.InReplyToStatusId != null)
1022             {
1023                 if (!posts.ContainsKey(nextPost.InReplyToStatusId.Value))
1024                     break;
1025                 nextPost = posts[nextPost.InReplyToStatusId.Value];
1026             }
1027
1028             return nextPost;
1029         }
1030
1031         public async Task GetRelatedResult(bool read, RelatedPostsTabModel tab)
1032         {
1033             var targetPost = tab.TargetPost;
1034             var relPosts = new Dictionary<Int64, PostClass>();
1035             if (targetPost.TextFromApi.Contains("@") && targetPost.InReplyToStatusId == null)
1036             {
1037                 //検索結果対応
1038                 var p = TabInformations.GetInstance()[targetPost.StatusId];
1039                 if (p != null && p.InReplyToStatusId != null)
1040                 {
1041                     targetPost = p;
1042                 }
1043                 else
1044                 {
1045                     p = await this.GetStatusApi(read, targetPost.StatusId)
1046                         .ConfigureAwait(false);
1047                     targetPost = p;
1048                 }
1049             }
1050             relPosts.Add(targetPost.StatusId, targetPost);
1051
1052             Exception lastException = null;
1053
1054             // in_reply_to_status_id を使用してリプライチェインを辿る
1055             var nextPost = FindTopOfReplyChain(relPosts, targetPost.StatusId);
1056             var loopCount = 1;
1057             while (nextPost.InReplyToStatusId != null && loopCount++ <= 20)
1058             {
1059                 var inReplyToId = nextPost.InReplyToStatusId.Value;
1060
1061                 var inReplyToPost = TabInformations.GetInstance()[inReplyToId];
1062                 if (inReplyToPost == null)
1063                 {
1064                     try
1065                     {
1066                         inReplyToPost = await this.GetStatusApi(read, inReplyToId)
1067                             .ConfigureAwait(false);
1068                     }
1069                     catch (WebApiException ex)
1070                     {
1071                         lastException = ex;
1072                         break;
1073                     }
1074                 }
1075
1076                 relPosts.Add(inReplyToPost.StatusId, inReplyToPost);
1077
1078                 nextPost = FindTopOfReplyChain(relPosts, nextPost.StatusId);
1079             }
1080
1081             //MRTとかに対応のためツイート内にあるツイートを指すURLを取り込む
1082             var text = targetPost.Text;
1083             var ma = Twitter.StatusUrlRegex.Matches(text).Cast<Match>()
1084                 .Concat(Twitter.ThirdPartyStatusUrlRegex.Matches(text).Cast<Match>());
1085             foreach (var _match in ma)
1086             {
1087                 if (Int64.TryParse(_match.Groups["StatusId"].Value, out var _statusId))
1088                 {
1089                     if (relPosts.ContainsKey(_statusId))
1090                         continue;
1091
1092                     var p = TabInformations.GetInstance()[_statusId];
1093                     if (p == null)
1094                     {
1095                         try
1096                         {
1097                             p = await this.GetStatusApi(read, _statusId)
1098                                 .ConfigureAwait(false);
1099                         }
1100                         catch (WebApiException ex)
1101                         {
1102                             lastException = ex;
1103                             break;
1104                         }
1105                     }
1106
1107                     if (p != null)
1108                         relPosts.Add(p.StatusId, p);
1109                 }
1110             }
1111
1112             relPosts.Values.ToList().ForEach(p =>
1113             {
1114                 if (p.IsMe && !read && this._readOwnPost)
1115                     p.IsRead = true;
1116                 else
1117                     p.IsRead = read;
1118
1119                 tab.AddPostQueue(p);
1120             });
1121
1122             if (lastException != null)
1123                 throw new WebApiException(lastException.Message, lastException);
1124         }
1125
1126         public async Task GetSearch(bool read, PublicSearchTabModel tab, bool more)
1127         {
1128             var count = GetApiResultCount(MyCommon.WORKERTYPE.PublicSearch, more, false);
1129
1130             long? maxId = null;
1131             long? sinceId = null;
1132             if (more)
1133             {
1134                 maxId = tab.OldestId - 1;
1135             }
1136             else
1137             {
1138                 sinceId = tab.SinceId;
1139             }
1140
1141             var searchResult = await this.Api.SearchTweets(tab.SearchWords, tab.SearchLang, count, maxId, sinceId)
1142                 .ConfigureAwait(false);
1143
1144             if (!TabInformations.GetInstance().ContainsTab(tab))
1145                 return;
1146
1147             var minimumId = this.CreatePostsFromSearchJson(searchResult, tab, read, more);
1148
1149             if (minimumId != null)
1150                 tab.OldestId = minimumId.Value;
1151         }
1152
1153         private void CreateDirectMessagesFromJson(TwitterDirectMessage[] item, MyCommon.WORKERTYPE gType, bool read)
1154         {
1155             foreach (var message in item)
1156             {
1157                 var post = new PostClass();
1158                 try
1159                 {
1160                     post.StatusId = message.Id;
1161                     if (gType != MyCommon.WORKERTYPE.UserStream)
1162                     {
1163                         if (gType == MyCommon.WORKERTYPE.DirectMessegeRcv)
1164                         {
1165                             if (minDirectmessage > post.StatusId) minDirectmessage = post.StatusId;
1166                         }
1167                         else
1168                         {
1169                             if (minDirectmessageSent > post.StatusId) minDirectmessageSent = post.StatusId;
1170                         }
1171                     }
1172
1173                     //二重取得回避
1174                     lock (LockObj)
1175                     {
1176                         if (TabInformations.GetInstance().GetTabByType(MyCommon.TabUsageType.DirectMessage).Contains(post.StatusId)) continue;
1177                     }
1178                     //sender_id
1179                     //recipient_id
1180                     post.CreatedAt = new DateTimeUtc(MyCommon.DateTimeParse(message.CreatedAt).ToUniversalTime());
1181                     //本文
1182                     var textFromApi = message.Text;
1183                     //HTMLに整形
1184                     post.Text = CreateHtmlAnchor(textFromApi, post.ReplyToList, message.Entities, post.Media);
1185                     post.TextFromApi = this.ReplaceTextFromApi(textFromApi, message.Entities);
1186                     post.TextFromApi = WebUtility.HtmlDecode(post.TextFromApi);
1187                     post.TextFromApi = post.TextFromApi.Replace("<3", "\u2661");
1188                     post.AccessibleText = this.CreateAccessibleText(textFromApi, message.Entities, quoteStatus: null);
1189                     post.AccessibleText = WebUtility.HtmlDecode(post.AccessibleText);
1190                     post.AccessibleText = post.AccessibleText.Replace("<3", "\u2661");
1191                     post.IsFav = false;
1192
1193                     post.QuoteStatusIds = GetQuoteTweetStatusIds(message.Entities).Distinct().ToArray();
1194
1195                     post.ExpandedUrls = message.Entities.OfType<TwitterEntityUrl>()
1196                         .Select(x => new PostClass.ExpandedUrlInfo(x.Url, x.ExpandedUrl))
1197                         .ToArray();
1198
1199                     //以下、ユーザー情報
1200                     TwitterUser user;
1201                     if (gType == MyCommon.WORKERTYPE.UserStream)
1202                     {
1203                         if (this.Api.CurrentUserId == message.Recipient.Id)
1204                         {
1205                             user = message.Sender;
1206                             post.IsMe = false;
1207                             post.IsOwl = true;
1208                         }
1209                         else
1210                         {
1211                             user = message.Recipient;
1212                             post.IsMe = true;
1213                             post.IsOwl = false;
1214                         }
1215                     }
1216                     else
1217                     {
1218                         if (gType == MyCommon.WORKERTYPE.DirectMessegeRcv)
1219                         {
1220                             user = message.Sender;
1221                             post.IsMe = false;
1222                             post.IsOwl = true;
1223                         }
1224                         else
1225                         {
1226                             user = message.Recipient;
1227                             post.IsMe = true;
1228                             post.IsOwl = false;
1229                         }
1230                     }
1231
1232                     post.UserId = user.Id;
1233                     post.ScreenName = user.ScreenName;
1234                     post.Nickname = user.Name.Trim();
1235                     post.ImageUrl = user.ProfileImageUrlHttps;
1236                     post.IsProtect = user.Protected;
1237
1238                     // メモリ使用量削減 (同一のテキストであれば同一の string インスタンスを参照させる)
1239                     if (post.Text == post.TextFromApi)
1240                         post.Text = post.TextFromApi;
1241                     if (post.AccessibleText == post.TextFromApi)
1242                         post.AccessibleText = post.TextFromApi;
1243
1244                     // 他の発言と重複しやすい (共通化できる) 文字列は string.Intern を通す
1245                     post.ScreenName = string.Intern(post.ScreenName);
1246                     post.Nickname = string.Intern(post.Nickname);
1247                     post.ImageUrl = string.Intern(post.ImageUrl);
1248                 }
1249                 catch(Exception ex)
1250                 {
1251                     MyCommon.TraceOut(ex, MethodBase.GetCurrentMethod().Name);
1252                     MessageBox.Show("Parse Error(CreateDirectMessagesFromJson)");
1253                     continue;
1254                 }
1255
1256                 post.IsRead = read;
1257                 if (post.IsMe && !read && _readOwnPost) post.IsRead = true;
1258                 post.IsReply = false;
1259                 post.IsExcludeReply = false;
1260                 post.IsDm = true;
1261
1262                 var dmTab = TabInformations.GetInstance().GetTabByType(MyCommon.TabUsageType.DirectMessage);
1263                 dmTab.AddPostQueue(post);
1264             }
1265         }
1266
1267         public async Task GetDirectMessageApi(bool read, MyCommon.WORKERTYPE gType, bool more)
1268         {
1269             this.CheckAccountState();
1270             this.CheckAccessLevel(TwitterApiAccessLevel.ReadWriteAndDirectMessage);
1271
1272             var count = GetApiResultCount(gType, more, false);
1273
1274             TwitterDirectMessage[] messages;
1275             if (gType == MyCommon.WORKERTYPE.DirectMessegeRcv)
1276             {
1277                 if (more)
1278                 {
1279                     messages = await this.Api.DirectMessagesRecv(count, maxId: this.minDirectmessage)
1280                         .ConfigureAwait(false);
1281                 }
1282                 else
1283                 {
1284                     messages = await this.Api.DirectMessagesRecv(count)
1285                         .ConfigureAwait(false);
1286                 }
1287             }
1288             else
1289             {
1290                 if (more)
1291                 {
1292                     messages = await this.Api.DirectMessagesSent(count, maxId: this.minDirectmessageSent)
1293                         .ConfigureAwait(false);
1294                 }
1295                 else
1296                 {
1297                     messages = await this.Api.DirectMessagesSent(count)
1298                         .ConfigureAwait(false);
1299                 }
1300             }
1301
1302             CreateDirectMessagesFromJson(messages, gType, read);
1303         }
1304
1305         public async Task GetFavoritesApi(bool read, FavoritesTabModel tab, bool backward)
1306         {
1307             this.CheckAccountState();
1308
1309             var count = GetApiResultCount(MyCommon.WORKERTYPE.Favorites, backward, false);
1310
1311             TwitterStatus[] statuses;
1312             if (backward)
1313             {
1314                 statuses = await this.Api.FavoritesList(count, maxId: tab.OldestId)
1315                     .ConfigureAwait(false);
1316             }
1317             else
1318             {
1319                 statuses = await this.Api.FavoritesList(count)
1320                     .ConfigureAwait(false);
1321             }
1322
1323             var minimumId = this.CreateFavoritePostsFromJson(statuses, read);
1324
1325             if (minimumId != null)
1326                 tab.OldestId = minimumId.Value;
1327         }
1328
1329         private string ReplaceTextFromApi(string text, TwitterEntities entities)
1330         {
1331             if (entities != null)
1332             {
1333                 if (entities.Urls != null)
1334                 {
1335                     foreach (var m in entities.Urls)
1336                     {
1337                         if (!string.IsNullOrEmpty(m.DisplayUrl)) text = text.Replace(m.Url, m.DisplayUrl);
1338                     }
1339                 }
1340                 if (entities.Media != null)
1341                 {
1342                     foreach (var m in entities.Media)
1343                     {
1344                         if (!string.IsNullOrEmpty(m.DisplayUrl)) text = text.Replace(m.Url, m.DisplayUrl);
1345                     }
1346                 }
1347             }
1348             return text;
1349         }
1350
1351         private string CreateAccessibleText(string text, TwitterEntities entities, TwitterStatus quoteStatus)
1352         {
1353             if (entities == null)
1354                 return text;
1355
1356             if (entities.Urls != null)
1357             {
1358                 foreach (var entity in entities.Urls)
1359                 {
1360                     if (quoteStatus != null)
1361                     {
1362                         var matchStatusUrl = Twitter.StatusUrlRegex.Match(entity.ExpandedUrl);
1363                         if (matchStatusUrl.Success && matchStatusUrl.Groups["StatusId"].Value == quoteStatus.IdStr)
1364                         {
1365                             var quoteText = this.CreateAccessibleText(quoteStatus.FullText, quoteStatus.MergedEntities, quoteStatus: null);
1366                             text = text.Replace(entity.Url, string.Format(Properties.Resources.QuoteStatus_AccessibleText, quoteStatus.User.ScreenName, quoteText));
1367                         }
1368                     }
1369                     else if (!string.IsNullOrEmpty(entity.DisplayUrl))
1370                     {
1371                         text = text.Replace(entity.Url, entity.DisplayUrl);
1372                     }
1373                 }
1374             }
1375
1376             if (entities.Media != null)
1377             {
1378                 foreach (var entity in entities.Media)
1379                 {
1380                     if (!string.IsNullOrEmpty(entity.AltText))
1381                     {
1382                         text = text.Replace(entity.Url, string.Format(Properties.Resources.ImageAltText, entity.AltText));
1383                     }
1384                     else if (!string.IsNullOrEmpty(entity.DisplayUrl))
1385                     {
1386                         text = text.Replace(entity.Url, entity.DisplayUrl);
1387                     }
1388                 }
1389             }
1390
1391             return text;
1392         }
1393
1394         /// <summary>
1395         /// フォロワーIDを更新します
1396         /// </summary>
1397         /// <exception cref="WebApiException"/>
1398         public async Task RefreshFollowerIds()
1399         {
1400             if (MyCommon._endingFlag) return;
1401
1402             var cursor = -1L;
1403             var newFollowerIds = new HashSet<long>();
1404             do
1405             {
1406                 var ret = await this.Api.FollowersIds(cursor)
1407                     .ConfigureAwait(false);
1408
1409                 if (ret.Ids == null)
1410                     throw new WebApiException("ret.ids == null");
1411
1412                 newFollowerIds.UnionWith(ret.Ids);
1413                 cursor = ret.NextCursor;
1414             } while (cursor != 0);
1415
1416             this.followerId = newFollowerIds;
1417             TabInformations.GetInstance().RefreshOwl(this.followerId);
1418
1419             this._GetFollowerResult = true;
1420         }
1421
1422         public bool GetFollowersSuccess
1423         {
1424             get
1425             {
1426                 return _GetFollowerResult;
1427             }
1428         }
1429
1430         /// <summary>
1431         /// RT 非表示ユーザーを更新します
1432         /// </summary>
1433         /// <exception cref="WebApiException"/>
1434         public async Task RefreshNoRetweetIds()
1435         {
1436             if (MyCommon._endingFlag) return;
1437
1438             this.noRTId = await this.Api.NoRetweetIds()
1439                 .ConfigureAwait(false);
1440
1441             this._GetNoRetweetResult = true;
1442         }
1443
1444         public bool GetNoRetweetSuccess
1445         {
1446             get
1447             {
1448                 return _GetNoRetweetResult;
1449             }
1450         }
1451
1452         /// <summary>
1453         /// t.co の文字列長などの設定情報を更新します
1454         /// </summary>
1455         /// <exception cref="WebApiException"/>
1456         public async Task RefreshConfiguration()
1457         {
1458             this.Configuration = await this.Api.Configuration()
1459                 .ConfigureAwait(false);
1460
1461             // TextConfiguration 相当の JSON を得る API が存在しないため、TransformedURLLength のみ help/configuration.json に合わせて更新する
1462             this.TextConfiguration.TransformedURLLength = this.Configuration.ShortUrlLengthHttps;
1463         }
1464
1465         public async Task GetListsApi()
1466         {
1467             this.CheckAccountState();
1468
1469             var ownedLists = await TwitterLists.GetAllItemsAsync(x =>
1470                 this.Api.ListsOwnerships(this.Username, cursor: x, count: 1000))
1471                     .ConfigureAwait(false);
1472
1473             var subscribedLists = await TwitterLists.GetAllItemsAsync(x =>
1474                 this.Api.ListsSubscriptions(this.Username, cursor: x, count: 1000))
1475                     .ConfigureAwait(false);
1476
1477             TabInformations.GetInstance().SubscribableLists = Enumerable.Concat(ownedLists, subscribedLists)
1478                 .Select(x => new ListElement(x, this))
1479                 .ToList();
1480         }
1481
1482         public async Task DeleteList(long listId)
1483         {
1484             await this.Api.ListsDestroy(listId)
1485                 .IgnoreResponse()
1486                 .ConfigureAwait(false);
1487
1488             var tabinfo = TabInformations.GetInstance();
1489
1490             tabinfo.SubscribableLists = tabinfo.SubscribableLists
1491                 .Where(x => x.Id != listId)
1492                 .ToList();
1493         }
1494
1495         public async Task<ListElement> EditList(long listId, string new_name, bool isPrivate, string description)
1496         {
1497             var response = await this.Api.ListsUpdate(listId, new_name, description, isPrivate)
1498                 .ConfigureAwait(false);
1499
1500             var list = await response.LoadJsonAsync()
1501                 .ConfigureAwait(false);
1502
1503             return new ListElement(list, this);
1504         }
1505
1506         public async Task<long> GetListMembers(long listId, List<UserInfo> lists, long cursor)
1507         {
1508             this.CheckAccountState();
1509
1510             var users = await this.Api.ListsMembers(listId, cursor)
1511                 .ConfigureAwait(false);
1512
1513             Array.ForEach(users.Users, u => lists.Add(new UserInfo(u)));
1514
1515             return users.NextCursor;
1516         }
1517
1518         public async Task CreateListApi(string listName, bool isPrivate, string description)
1519         {
1520             this.CheckAccountState();
1521
1522             var response = await this.Api.ListsCreate(listName, description, isPrivate)
1523                 .ConfigureAwait(false);
1524
1525             var list = await response.LoadJsonAsync()
1526                 .ConfigureAwait(false);
1527
1528             TabInformations.GetInstance().SubscribableLists.Add(new ListElement(list, this));
1529         }
1530
1531         public async Task<bool> ContainsUserAtList(long listId, string user)
1532         {
1533             this.CheckAccountState();
1534
1535             try
1536             {
1537                 await this.Api.ListsMembersShow(listId, user)
1538                     .ConfigureAwait(false);
1539
1540                 return true;
1541             }
1542             catch (TwitterApiException ex)
1543                 when (ex.ErrorResponse.Errors.Any(x => x.Code == TwitterErrorCode.NotFound))
1544             {
1545                 return false;
1546             }
1547         }
1548
1549         public string CreateHtmlAnchor(string text, List<Tuple<long, string>> AtList, TwitterEntities entities, List<MediaInfo> media)
1550         {
1551             if (entities != null)
1552             {
1553                 if (entities.Hashtags != null)
1554                 {
1555                     lock (this.LockObj)
1556                     {
1557                         this._hashList.AddRange(entities.Hashtags.Select(x => "#" + x.Text));
1558                     }
1559                 }
1560                 if (entities.UserMentions != null)
1561                 {
1562                     foreach (var ent in entities.UserMentions)
1563                     {
1564                         AtList.Add(Tuple.Create(ent.Id, ent.ScreenName));
1565                     }
1566                 }
1567                 if (entities.Media != null)
1568                 {
1569                     if (media != null)
1570                     {
1571                         foreach (var ent in entities.Media)
1572                         {
1573                             if (!media.Any(x => x.Url == ent.MediaUrl))
1574                             {
1575                                 if (ent.VideoInfo != null &&
1576                                     ent.Type == "animated_gif" || ent.Type == "video")
1577                                 {
1578                                     //var videoUrl = ent.VideoInfo.Variants
1579                                     //    .Where(v => v.ContentType == "video/mp4")
1580                                     //    .OrderByDescending(v => v.Bitrate)
1581                                     //    .Select(v => v.Url).FirstOrDefault();
1582                                     media.Add(new MediaInfo(ent.MediaUrl, ent.AltText, ent.ExpandedUrl));
1583                                 }
1584                                 else
1585                                     media.Add(new MediaInfo(ent.MediaUrl, ent.AltText, videoUrl: null));
1586                             }
1587                         }
1588                     }
1589                 }
1590             }
1591
1592             // PostClass.ExpandedUrlInfo を使用して非同期に URL 展開を行うためここでは expanded_url を使用しない
1593             text = TweetFormatter.AutoLinkHtml(text, entities, keepTco: true);
1594
1595             text = Regex.Replace(text, "(^|[^a-zA-Z0-9_/&#＃@＠>=.~])(sm|nm)([0-9]{1,10})", "$1<a href=\"http://www.nicovideo.jp/watch/$2$3\">$2$3</a>");
1596             text = PreProcessUrl(text); //IDN置換
1597
1598             return text;
1599         }
1600
1601         private static readonly Uri SourceUriBase = new Uri("https://twitter.com/");
1602
1603         /// <summary>
1604         /// Twitter APIから得たHTML形式のsource文字列を分析し、source名とURLに分離します
1605         /// </summary>
1606         internal static (string SourceText, Uri SourceUri) ParseSource(string sourceHtml)
1607         {
1608             if (string.IsNullOrEmpty(sourceHtml))
1609                 return ("", null);
1610
1611             string sourceText;
1612             Uri sourceUri;
1613
1614             // sourceHtmlの例: <a href="http://twitter.com" rel="nofollow">Twitter Web Client</a>
1615
1616             var match = Regex.Match(sourceHtml, "^<a href=\"(?<uri>.+?)\".*?>(?<text>.+)</a>$", RegexOptions.IgnoreCase);
1617             if (match.Success)
1618             {
1619                 sourceText = WebUtility.HtmlDecode(match.Groups["text"].Value);
1620                 try
1621                 {
1622                     var uriStr = WebUtility.HtmlDecode(match.Groups["uri"].Value);
1623                     sourceUri = new Uri(SourceUriBase, uriStr);
1624                 }
1625                 catch (UriFormatException)
1626                 {
1627                     sourceUri = null;
1628                 }
1629             }
1630             else
1631             {
1632                 sourceText = WebUtility.HtmlDecode(sourceHtml);
1633                 sourceUri = null;
1634             }
1635
1636             return (sourceText, sourceUri);
1637         }
1638
1639         public async Task<TwitterApiStatus> GetInfoApi()
1640         {
1641             if (Twitter.AccountState != MyCommon.ACCOUNT_STATE.Valid) return null;
1642
1643             if (MyCommon._endingFlag) return null;
1644
1645             var limits = await this.Api.ApplicationRateLimitStatus()
1646                 .ConfigureAwait(false);
1647
1648             MyCommon.TwitterApiInfo.UpdateFromJson(limits);
1649
1650             return MyCommon.TwitterApiInfo;
1651         }
1652
1653         /// <summary>
1654         /// ブロック中のユーザーを更新します
1655         /// </summary>
1656         /// <exception cref="WebApiException"/>
1657         public async Task RefreshBlockIds()
1658         {
1659             if (MyCommon._endingFlag) return;
1660
1661             var cursor = -1L;
1662             var newBlockIds = new HashSet<long>();
1663             do
1664             {
1665                 var ret = await this.Api.BlocksIds(cursor)
1666                     .ConfigureAwait(false);
1667
1668                 newBlockIds.UnionWith(ret.Ids);
1669                 cursor = ret.NextCursor;
1670             } while (cursor != 0);
1671
1672             newBlockIds.Remove(this.UserId); // 元のソースにあったので一応残しておく
1673
1674             TabInformations.GetInstance().BlockIds = newBlockIds;
1675         }
1676
1677         /// <summary>
1678         /// ミュート中のユーザーIDを更新します
1679         /// </summary>
1680         /// <exception cref="WebApiException"/>
1681         public async Task RefreshMuteUserIdsAsync()
1682         {
1683             if (MyCommon._endingFlag) return;
1684
1685             var ids = await TwitterIds.GetAllItemsAsync(x => this.Api.MutesUsersIds(x))
1686                 .ConfigureAwait(false);
1687
1688             TabInformations.GetInstance().MuteUserIds = new HashSet<long>(ids);
1689         }
1690
1691         public string[] GetHashList()
1692         {
1693             string[] hashArray;
1694             lock (LockObj)
1695             {
1696                 hashArray = _hashList.ToArray();
1697                 _hashList.Clear();
1698             }
1699             return hashArray;
1700         }
1701
1702         public string AccessToken
1703             => ((TwitterApiConnection)this.Api.Connection).AccessToken;
1704
1705         public string AccessTokenSecret
1706             => ((TwitterApiConnection)this.Api.Connection).AccessSecret;
1707
1708         private void CheckAccountState()
1709         {
1710             if (Twitter.AccountState != MyCommon.ACCOUNT_STATE.Valid)
1711                 throw new WebApiException("Auth error. Check your account");
1712         }
1713
1714         private void CheckAccessLevel(TwitterApiAccessLevel accessLevelFlags)
1715         {
1716             if (!this.AccessLevel.HasFlag(accessLevelFlags))
1717                 throw new WebApiException("Auth Err:try to re-authorization.");
1718         }
1719
1720         public int GetTextLengthRemain(string postText)
1721         {
1722             var matchDm = Twitter.DMSendTextRegex.Match(postText);
1723             if (matchDm.Success)
1724                 return this.GetTextLengthRemainDM(matchDm.Groups["body"].Value);
1725
1726             return this.GetTextLengthRemainWeighted(postText);
1727         }
1728
1729         private int GetTextLengthRemainDM(string postText)
1730         {
1731             var textLength = 0;
1732
1733             var pos = 0;
1734             while (pos < postText.Length)
1735             {
1736                 textLength++;
1737
1738                 if (char.IsSurrogatePair(postText, pos))
1739                     pos += 2; // サロゲートペアの場合は2文字分進める
1740                 else
1741                     pos++;
1742             }
1743
1744             var urls = TweetExtractor.ExtractUrls(postText);
1745             foreach (var url in urls)
1746             {
1747                 var shortUrlLength = url.StartsWith("https://", StringComparison.OrdinalIgnoreCase)
1748                     ? this.Configuration.ShortUrlLengthHttps
1749                     : this.Configuration.ShortUrlLength;
1750
1751                 textLength += shortUrlLength - url.Length;
1752             }
1753
1754             return this.Configuration.DmTextCharacterLimit - textLength;
1755         }
1756
1757         private int GetTextLengthRemainWeighted(string postText)
1758         {
1759             var config = this.TextConfiguration;
1760             var totalWeight = 0;
1761
1762             var urls = TweetExtractor.ExtractUrlEntities(postText).ToArray();
1763
1764             var pos = 0;
1765             while (pos < postText.Length)
1766             {
1767                 var urlEntity = urls.FirstOrDefault(x => x.Indices[0] == pos);
1768                 if (urlEntity != null)
1769                 {
1770                     totalWeight += config.TransformedURLLength * config.Scale;
1771
1772                     var urlLength = urlEntity.Indices[1] - urlEntity.Indices[0];
1773                     pos += urlLength;
1774
1775                     continue;
1776                 }
1777
1778                 var codepoint = postText.GetCodepointAtSafe(pos);
1779                 var weight = config.DefaultWeight;
1780
1781                 foreach (var weightRange in config.Ranges)
1782                 {
1783                     if (codepoint >= weightRange.Start && codepoint <= weightRange.End)
1784                     {
1785                         weight = weightRange.Weight;
1786                         break;
1787                     }
1788                 }
1789
1790                 totalWeight += weight;
1791
1792                 var isSurrogatePair = codepoint > 0xffff;
1793                 if (isSurrogatePair)
1794                     pos += 2; // サロゲートペアの場合は2文字分進める
1795                 else
1796                     pos++;
1797             }
1798
1799             var remainWeight = config.MaxWeightedTweetLength * config.Scale - totalWeight;
1800
1801             return remainWeight / config.Scale;
1802         }
1803
1804
1805 #region "UserStream"
1806         private string trackWord_ = "";
1807         public string TrackWord
1808         {
1809             get
1810             {
1811                 return trackWord_;
1812             }
1813             set
1814             {
1815                 trackWord_ = value;
1816             }
1817         }
1818         private bool allAtReply_ = false;
1819         public bool AllAtReply
1820         {
1821             get
1822             {
1823                 return allAtReply_;
1824             }
1825             set
1826             {
1827                 allAtReply_ = value;
1828             }
1829         }
1830
1831         public event EventHandler NewPostFromStream;
1832         public event EventHandler UserStreamStarted;
1833         public event EventHandler UserStreamStopped;
1834         public event EventHandler<PostDeletedEventArgs> PostDeleted;
1835         public event EventHandler<UserStreamEventReceivedEventArgs> UserStreamEventReceived;
1836         private DateTimeUtc _lastUserstreamDataReceived;
1837         private TwitterUserstream userStream;
1838
1839         public class FormattedEvent
1840         {
1841             public MyCommon.EVENTTYPE Eventtype { get; set; }
1842             public DateTimeUtc CreatedAt { get; set; }
1843             public string Event { get; set; }
1844             public string Username { get; set; }
1845             public string Target { get; set; }
1846             public Int64 Id { get; set; }
1847             public bool IsMe { get; set; }
1848         }
1849
1850         public List<FormattedEvent> storedEvent_ = new List<FormattedEvent>();
1851         public List<FormattedEvent> StoredEvent
1852         {
1853             get
1854             {
1855                 return storedEvent_;
1856             }
1857             set
1858             {
1859                 storedEvent_ = value;
1860             }
1861         }
1862
1863         private readonly IReadOnlyDictionary<string, MyCommon.EVENTTYPE> eventTable = new Dictionary<string, MyCommon.EVENTTYPE>
1864         {
1865             ["favorite"] = MyCommon.EVENTTYPE.Favorite,
1866             ["unfavorite"] = MyCommon.EVENTTYPE.Unfavorite,
1867             ["follow"] = MyCommon.EVENTTYPE.Follow,
1868             ["list_member_added"] = MyCommon.EVENTTYPE.ListMemberAdded,
1869             ["list_member_removed"] = MyCommon.EVENTTYPE.ListMemberRemoved,
1870             ["block"] = MyCommon.EVENTTYPE.Block,
1871             ["unblock"] = MyCommon.EVENTTYPE.Unblock,
1872             ["user_update"] = MyCommon.EVENTTYPE.UserUpdate,
1873             ["deleted"] = MyCommon.EVENTTYPE.Deleted,
1874             ["list_created"] = MyCommon.EVENTTYPE.ListCreated,
1875             ["list_destroyed"] = MyCommon.EVENTTYPE.ListDestroyed,
1876             ["list_updated"] = MyCommon.EVENTTYPE.ListUpdated,
1877             ["unfollow"] = MyCommon.EVENTTYPE.Unfollow,
1878             ["list_user_subscribed"] = MyCommon.EVENTTYPE.ListUserSubscribed,
1879             ["list_user_unsubscribed"] = MyCommon.EVENTTYPE.ListUserUnsubscribed,
1880             ["mute"] = MyCommon.EVENTTYPE.Mute,
1881             ["unmute"] = MyCommon.EVENTTYPE.Unmute,
1882             ["quoted_tweet"] = MyCommon.EVENTTYPE.QuotedTweet,
1883         };
1884
1885         public bool IsUserstreamDataReceived
1886             => (DateTimeUtc.Now - this._lastUserstreamDataReceived).TotalSeconds < 31;
1887
1888         private void userStream_StatusArrived(string line)
1889         {
1890             this._lastUserstreamDataReceived = DateTimeUtc.Now;
1891             if (string.IsNullOrEmpty(line)) return;
1892
1893             if (line.First() != '{' || line.Last() != '}')
1894             {
1895                 MyCommon.TraceOut("Invalid JSON (StatusArrived):" + Environment.NewLine + line);
1896                 return;
1897             }
1898
1899             var isDm = false;
1900
1901             try
1902             {
1903                 using (var jsonReader = JsonReaderWriterFactory.CreateJsonReader(Encoding.UTF8.GetBytes(line), XmlDictionaryReaderQuotas.Max))
1904                 {
1905                     var xElm = XElement.Load(jsonReader);
1906                     if (xElm.Element("friends") != null)
1907                     {
1908                         Debug.WriteLine("friends");
1909                         return;
1910                     }
1911                     else if (xElm.Element("delete") != null)
1912                     {
1913                         Debug.WriteLine("delete");
1914                         Int64 id;
1915                         XElement idElm;
1916                         if ((idElm = xElm.Element("delete").Element("direct_message")?.Element("id")) != null)
1917                         {
1918                             id = 0;
1919                             long.TryParse(idElm.Value, out id);
1920
1921                             this.PostDeleted?.Invoke(this, new PostDeletedEventArgs(id));
1922                         }
1923                         else if ((idElm = xElm.Element("delete").Element("status")?.Element("id")) != null)
1924                         {
1925                             id = 0;
1926                             long.TryParse(idElm.Value, out id);
1927
1928                             this.PostDeleted?.Invoke(this, new PostDeletedEventArgs(id));
1929                         }
1930                         else
1931                         {
1932                             MyCommon.TraceOut("delete:" + line);
1933                             return;
1934                         }
1935                         for (int i = this.StoredEvent.Count - 1; i >= 0; i--)
1936                         {
1937                             var sEvt = this.StoredEvent[i];
1938                             if (sEvt.Id == id && (sEvt.Event == "favorite" || sEvt.Event == "unfavorite"))
1939                             {
1940                                 this.StoredEvent.RemoveAt(i);
1941                             }
1942                         }
1943                         return;
1944                     }
1945                     else if (xElm.Element("limit") != null)
1946                     {
1947                         Debug.WriteLine(line);
1948                         return;
1949                     }
1950                     else if (xElm.Element("event") != null)
1951                     {
1952                         Debug.WriteLine("event: " + xElm.Element("event").Value);
1953                         CreateEventFromJson(line);
1954                         return;
1955                     }
1956                     else if (xElm.Element("direct_message") != null)
1957                     {
1958                         Debug.WriteLine("direct_message");
1959                         isDm = true;
1960                     }
1961                     else if (xElm.Element("retweeted_status") != null)
1962                     {
1963                         var sourceUserId = xElm.XPathSelectElement("/user/id_str").Value;
1964                         var targetUserId = xElm.XPathSelectElement("/retweeted_status/user/id_str").Value;
1965
1966                         // 自分に関係しないリツイートの場合は無視する
1967                         var selfUserId = this.UserId.ToString();
1968                         if (sourceUserId == selfUserId || targetUserId == selfUserId)
1969                         {
1970                             // 公式 RT をイベントとしても扱う
1971                             var evt = CreateEventFromRetweet(xElm);
1972                             if (evt != null)
1973                             {
1974                                 this.StoredEvent.Insert(0, evt);
1975
1976                                 this.UserStreamEventReceived?.Invoke(this, new UserStreamEventReceivedEventArgs(evt));
1977                             }
1978                         }
1979
1980                         // 従来通り公式 RT の表示も行うため return しない
1981                     }
1982                     else if (xElm.Element("scrub_geo") != null)
1983                     {
1984                         try
1985                         {
1986                             TabInformations.GetInstance().ScrubGeoReserve(long.Parse(xElm.Element("scrub_geo").Element("user_id").Value),
1987                                                                         long.Parse(xElm.Element("scrub_geo").Element("up_to_status_id").Value));
1988                         }
1989                         catch(Exception)
1990                         {
1991                             MyCommon.TraceOut("scrub_geo:" + line);
1992                         }
1993                         return;
1994                     }
1995                 }
1996
1997                 if (isDm)
1998                 {
1999                     try
2000                     {
2001                         var message = TwitterStreamEventDirectMessage.ParseJson(line).DirectMessage;
2002                         this.CreateDirectMessagesFromJson(new[] { message }, MyCommon.WORKERTYPE.UserStream, false);
2003                     }
2004                     catch (SerializationException ex)
2005                     {
2006                         throw TwitterApiException.CreateFromException(ex, line);
2007                     }
2008                 }
2009                 else
2010                 {
2011                     try
2012                     {
2013                         var status = TwitterStatusCompat.ParseJson(line);
2014                         this.CreatePostsFromJson(new[] { status.Normalize() }, MyCommon.WORKERTYPE.UserStream, null, false);
2015                     }
2016                     catch (SerializationException ex)
2017                     {
2018                         throw TwitterApiException.CreateFromException(ex, line);
2019                     }
2020                 }
2021             }
2022             catch (WebApiException ex)
2023             {
2024                 MyCommon.TraceOut(ex);
2025                 return;
2026             }
2027             catch (XmlException)
2028             {
2029                 MyCommon.TraceOut("XmlException (StatusArrived): " + line);
2030             }
2031             catch(NullReferenceException)
2032             {
2033                 MyCommon.TraceOut("NullRef StatusArrived: " + line);
2034             }
2035
2036             this.NewPostFromStream?.Invoke(this, EventArgs.Empty);
2037         }
2038
2039         /// <summary>
2040         /// UserStreamsから受信した公式RTをイベントに変換します
2041         /// </summary>
2042         private FormattedEvent CreateEventFromRetweet(XElement xElm)
2043         {
2044             return new FormattedEvent
2045             {
2046                 Eventtype = MyCommon.EVENTTYPE.Retweet,
2047                 Event = "retweet",
2048                 CreatedAt = new DateTimeUtc(MyCommon.DateTimeParse(xElm.XPathSelectElement("/created_at").Value).ToUniversalTime()),
2049                 IsMe = xElm.XPathSelectElement("/user/id_str").Value == this.UserId.ToString(),
2050                 Username = xElm.XPathSelectElement("/user/screen_name").Value,
2051                 Target = string.Format("@{0}:{1}", new[]
2052                 {
2053                     xElm.XPathSelectElement("/retweeted_status/user/screen_name").Value,
2054                     WebUtility.HtmlDecode(xElm.XPathSelectElement("/retweeted_status/text").Value),
2055                 }),
2056                 Id = long.Parse(xElm.XPathSelectElement("/retweeted_status/id_str").Value),
2057             };
2058         }
2059
2060         private void CreateEventFromJson(string content)
2061         {
2062             TwitterStreamEvent eventData = null;
2063             try
2064             {
2065                 eventData = TwitterStreamEvent.ParseJson(content);
2066             }
2067             catch(SerializationException ex)
2068             {
2069                 MyCommon.TraceOut(ex, "Event Serialize Exception!" + Environment.NewLine + content);
2070             }
2071             catch(Exception ex)
2072             {
2073                 MyCommon.TraceOut(ex, "Event Exception!" + Environment.NewLine + content);
2074             }
2075
2076             var evt = new FormattedEvent();
2077             evt.CreatedAt = new DateTimeUtc(MyCommon.DateTimeParse(eventData.CreatedAt).ToUniversalTime());
2078             evt.Event = eventData.Event;
2079             evt.Username = eventData.Source.ScreenName;
2080             evt.IsMe = evt.Username.ToLowerInvariant().Equals(this.Username.ToLowerInvariant());
2081
2082             eventTable.TryGetValue(eventData.Event, out var eventType);
2083             evt.Eventtype = eventType;
2084
2085             TwitterStreamEvent<TwitterStatusCompat> tweetEvent;
2086             TwitterStatus tweet;
2087
2088             switch (eventData.Event)
2089             {
2090                 case "access_revoked":
2091                 case "access_unrevoked":
2092                 case "user_delete":
2093                 case "user_suspend":
2094                     return;
2095                 case "follow":
2096                     if (eventData.Target.ScreenName.ToLowerInvariant().Equals(_uname))
2097                     {
2098                         if (!this.followerId.Contains(eventData.Source.Id)) this.followerId.Add(eventData.Source.Id);
2099                     }
2100                     else
2101                     {
2102                         return;    //Block後のUndoをすると、SourceとTargetが逆転したfollowイベントが帰ってくるため。
2103                     }
2104                     evt.Target = "";
2105                     break;
2106                 case "unfollow":
2107                     evt.Target = "@" + eventData.Target.ScreenName;
2108                     break;
2109                 case "favorited_retweet":
2110                 case "retweeted_retweet":
2111                     return;
2112                 case "favorite":
2113                 case "unfavorite":
2114                     tweetEvent = TwitterStreamEvent<TwitterStatusCompat>.ParseJson(content);
2115                     tweet = tweetEvent.TargetObject.Normalize();
2116                     evt.Target = "@" + tweet.User.ScreenName + ":" + WebUtility.HtmlDecode(tweet.FullText);
2117                     evt.Id = tweet.Id;
2118
2119                     if (SettingManager.Common.IsRemoveSameEvent)
2120                     {
2121                         if (this.StoredEvent.Any(ev => ev.Username == evt.Username && ev.Eventtype == evt.Eventtype && ev.Target == evt.Target))
2122                             return;
2123                     }
2124
2125                     var tabinfo = TabInformations.GetInstance();
2126
2127                     var statusId = tweet.Id;
2128                     if (!tabinfo.Posts.TryGetValue(statusId, out var post))
2129                         break;
2130
2131                     if (eventData.Event == "favorite")
2132                     {
2133                         var favTab = tabinfo.GetTabByType(MyCommon.TabUsageType.Favorites);
2134                         favTab.AddPostQueue(post);
2135
2136                         if (tweetEvent.Source.Id == this.UserId)
2137                         {
2138                             post.IsFav = true;
2139                         }
2140                         else if (tweetEvent.Target.Id == this.UserId)
2141                         {
2142                             post.FavoritedCount++;
2143
2144                             if (SettingManager.Common.FavEventUnread)
2145                                 tabinfo.SetReadAllTab(post.StatusId, read: false);
2146                         }
2147                     }
2148                     else // unfavorite
2149                     {
2150                         if (tweetEvent.Source.Id == this.UserId)
2151                         {
2152                             post.IsFav = false;
2153                         }
2154                         else if (tweetEvent.Target.Id == this.UserId)
2155                         {
2156                             post.FavoritedCount = Math.Max(0, post.FavoritedCount - 1);
2157                         }
2158                     }
2159                     break;
2160                 case "quoted_tweet":
2161                     if (evt.IsMe) return;
2162
2163                     tweetEvent = TwitterStreamEvent<TwitterStatusCompat>.ParseJson(content);
2164                     tweet = tweetEvent.TargetObject.Normalize();
2165                     evt.Target = "@" + tweet.User.ScreenName + ":" + WebUtility.HtmlDecode(tweet.FullText);
2166                     evt.Id = tweet.Id;
2167
2168                     if (SettingManager.Common.IsRemoveSameEvent)
2169                     {
2170                         if (this.StoredEvent.Any(ev => ev.Username == evt.Username && ev.Eventtype == evt.Eventtype && ev.Target == evt.Target))
2171                             return;
2172                     }
2173                     break;
2174                 case "list_member_added":
2175                 case "list_member_removed":
2176                 case "list_created":
2177                 case "list_destroyed":
2178                 case "list_updated":
2179                 case "list_user_subscribed":
2180                 case "list_user_unsubscribed":
2181                     var listEvent = TwitterStreamEvent<TwitterList>.ParseJson(content);
2182                     evt.Target = listEvent.TargetObject.FullName;
2183                     break;
2184                 case "block":
2185                     if (!TabInformations.GetInstance().BlockIds.Contains(eventData.Target.Id)) TabInformations.GetInstance().BlockIds.Add(eventData.Target.Id);
2186                     evt.Target = "";
2187                     break;
2188                 case "unblock":
2189                     if (TabInformations.GetInstance().BlockIds.Contains(eventData.Target.Id)) TabInformations.GetInstance().BlockIds.Remove(eventData.Target.Id);
2190                     evt.Target = "";
2191                     break;
2192                 case "user_update":
2193                     evt.Target = "";
2194                     break;
2195
2196                 // Mute / Unmute
2197                 case "mute":
2198                     evt.Target = "@" + eventData.Target.ScreenName;
2199                     if (!TabInformations.GetInstance().MuteUserIds.Contains(eventData.Target.Id))
2200                     {
2201                         TabInformations.GetInstance().MuteUserIds.Add(eventData.Target.Id);
2202                     }
2203                     break;
2204                 case "unmute":
2205                     evt.Target = "@" + eventData.Target.ScreenName;
2206                     if (TabInformations.GetInstance().MuteUserIds.Contains(eventData.Target.Id))
2207                     {
2208                         TabInformations.GetInstance().MuteUserIds.Remove(eventData.Target.Id);
2209                     }
2210                     break;
2211
2212                 default:
2213                     MyCommon.TraceOut("Unknown Event:" + evt.Event + Environment.NewLine + content);
2214                     break;
2215             }
2216             this.StoredEvent.Insert(0, evt);
2217
2218             this.UserStreamEventReceived?.Invoke(this, new UserStreamEventReceivedEventArgs(evt));
2219         }
2220
2221         private void userStream_Started()
2222         {
2223             this.UserStreamStarted?.Invoke(this, EventArgs.Empty);
2224         }
2225
2226         private void userStream_Stopped()
2227         {
2228             this.UserStreamStopped?.Invoke(this, EventArgs.Empty);
2229         }
2230
2231         public bool UserStreamActive
2232             => this.userStream != null && this.userStream.IsStreamActive;
2233
2234         public void StartUserStream()
2235         {
2236             var newStream = new TwitterUserstream(this.Api);
2237
2238             newStream.StatusArrived += userStream_StatusArrived;
2239             newStream.Started += userStream_Started;
2240             newStream.Stopped += userStream_Stopped;
2241
2242             newStream.Start(this.AllAtReply, this.TrackWord);
2243
2244             var oldStream = Interlocked.Exchange(ref this.userStream, newStream);
2245             oldStream?.Dispose();
2246         }
2247
2248         public void StopUserStream()
2249         {
2250             var oldStream = Interlocked.Exchange(ref this.userStream, null);
2251             oldStream?.Dispose();
2252         }
2253
2254         public void ReconnectUserStream()
2255         {
2256             if (this.userStream != null)
2257             {
2258                 this.StartUserStream();
2259             }
2260         }
2261
2262         private class TwitterUserstream : IDisposable
2263         {
2264             public bool AllAtReplies { get; private set; }
2265             public string TrackWords { get; private set; }
2266
2267             public bool IsStreamActive { get; private set; }
2268
2269             public event Action<string> StatusArrived;
2270             public event Action Stopped;
2271             public event Action Started;
2272
2273             private TwitterApi twitterApi;
2274
2275             private Task streamTask;
2276             private CancellationTokenSource streamCts;
2277
2278             public TwitterUserstream(TwitterApi twitterApi)
2279             {
2280                 this.twitterApi = twitterApi;
2281             }
2282
2283             public void Start(bool allAtReplies, string trackwords)
2284             {
2285                 this.AllAtReplies = allAtReplies;
2286                 this.TrackWords = trackwords;
2287
2288                 var cts = new CancellationTokenSource();
2289
2290                 this.streamCts = cts;
2291                 this.streamTask = Task.Run(async () =>
2292                 {
2293                     try
2294                     {
2295                         await this.UserStreamLoop(cts.Token)
2296                             .ConfigureAwait(false);
2297                     }
2298                     catch (OperationCanceledException) { }
2299                 });
2300             }
2301
2302             public void Stop()
2303             {
2304                 this.streamCts?.Cancel();
2305
2306                 // streamTask の完了を待たずに IsStreamActive を false にセットする
2307                 this.IsStreamActive = false;
2308                 this.Stopped?.Invoke();
2309             }
2310
2311             private async Task UserStreamLoop(CancellationToken cancellationToken)
2312             {
2313                 TimeSpan sleep = TimeSpan.Zero;
2314                 for (;;)
2315                 {
2316                     if (sleep != TimeSpan.Zero)
2317                     {
2318                         await Task.Delay(sleep, cancellationToken)
2319                             .ConfigureAwait(false);
2320                         sleep = TimeSpan.Zero;
2321                     }
2322
2323                     if (!MyCommon.IsNetworkAvailable())
2324                     {
2325                         sleep = TimeSpan.FromSeconds(30);
2326                         continue;
2327                     }
2328
2329                     this.IsStreamActive = true;
2330                     this.Started?.Invoke();
2331
2332                     try
2333                     {
2334                         var replies = this.AllAtReplies ? "all" : null;
2335
2336                         using (var stream = await this.twitterApi.UserStreams(replies, this.TrackWords)
2337                             .ConfigureAwait(false))
2338                         using (var reader = new StreamReader(stream))
2339                         {
2340                             while (!reader.EndOfStream)
2341                             {
2342                                 var line = await reader.ReadLineAsync()
2343                                     .ConfigureAwait(false);
2344
2345                                 cancellationToken.ThrowIfCancellationRequested();
2346
2347                                 this.StatusArrived?.Invoke(line);
2348                             }
2349                         }
2350
2351                         // キャンセルされていないのにストリームが終了した場合
2352                         sleep = TimeSpan.FromSeconds(30);
2353                     }
2354                     catch (TwitterApiException) { sleep = TimeSpan.FromSeconds(30); }
2355                     catch (IOException) { sleep = TimeSpan.FromSeconds(30); }
2356                     catch (OperationCanceledException)
2357                     {
2358                         if (cancellationToken.IsCancellationRequested)
2359                             throw;
2360
2361                         // cancellationToken によるキャンセルではない（＝タイムアウトエラー）
2362                         sleep = TimeSpan.FromSeconds(30);
2363                     }
2364                     catch (Exception ex)
2365                     {
2366                         MyCommon.ExceptionOut(ex);
2367                         sleep = TimeSpan.FromSeconds(30);
2368                     }
2369                     finally
2370                     {
2371                         this.IsStreamActive = false;
2372                         this.Stopped?.Invoke();
2373                     }
2374                 }
2375             }
2376
2377             private bool disposed = false;
2378
2379             public void Dispose()
2380             {
2381                 if (this.disposed)
2382                     return;
2383
2384                 this.disposed = true;
2385
2386                 this.Stop();
2387
2388                 this.Started = null;
2389                 this.Stopped = null;
2390                 this.StatusArrived = null;
2391             }
2392         }
2393 #endregion
2394
2395 #region "IDisposable Support"
2396         private bool disposedValue; // 重複する呼び出しを検出するには
2397
2398         // IDisposable
2399         protected virtual void Dispose(bool disposing)
2400         {
2401             if (!this.disposedValue)
2402             {
2403                 if (disposing)
2404                 {
2405                     this.StopUserStream();
2406                 }
2407             }
2408             this.disposedValue = true;
2409         }
2410
2411         //protected Overrides void Finalize()
2412         //{
2413         //    // このコードを変更しないでください。クリーンアップ コードを上の Dispose(bool disposing) に記述します。
2414         //    Dispose(false)
2415         //    MyBase.Finalize()
2416         //}
2417
2418         // このコードは、破棄可能なパターンを正しく実装できるように Visual Basic によって追加されました。
2419         public void Dispose()
2420         {
2421             // このコードを変更しないでください。クリーンアップ コードを上の Dispose(bool disposing) に記述します。
2422             Dispose(true);
2423             GC.SuppressFinalize(this);
2424         }
2425 #endregion
2426     }
2427
2428     public class PostDeletedEventArgs : EventArgs
2429     {
2430         public long StatusId { get; }
2431
2432         public PostDeletedEventArgs(long statusId)
2433         {
2434             this.StatusId = statusId;
2435         }
2436     }
2437
2438     public class UserStreamEventReceivedEventArgs : EventArgs
2439     {
2440         public Twitter.FormattedEvent EventData { get; }
2441
2442         public UserStreamEventReceivedEventArgs(Twitter.FormattedEvent eventData)
2443         {
2444             this.EventData = eventData;
2445         }
2446     }
2447 }